sig
  module Std :
    sig
      module Integer :
        sig
          module type Base =
            sig
              type t
              val zero : Bap.Std.Integer.Base.t
              val one : Bap.Std.Integer.Base.t
              val succ : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val pred : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val abs : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val neg : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val add :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val sub :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val mul :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val div :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val modulo :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val lnot : Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val logand :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val logor :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val logxor :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val lshift :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val rshift :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
              val arshift :
                Bap.Std.Integer.Base.t ->
                Bap.Std.Integer.Base.t -> Bap.Std.Integer.Base.t
            end
          module type S =
            sig
              type t
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( + ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( - ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( * ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( / ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( mod ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( land ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( lor ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( lxor ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( lsl ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( lsr ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
              val ( asr ) :
                Bap.Std.Integer.S.t ->
                Bap.Std.Integer.S.t -> Bap.Std.Integer.S.t
            end
          module Make :
            functor (T : Base->
              sig
                type t = T.t
                val zero : t
                val one : t
                val succ : t -> t
                val pred : t -> t
                val abs : t -> t
                val neg : t -> t
                val add : t -> t -> t
                val sub : t -> t -> t
                val mul : t -> t -> t
                val div : t -> t -> t
                val modulo : t -> t -> t
                val lnot : t -> t
                val logand : t -> t -> t
                val logor : t -> t -> t
                val logxor : t -> t -> t
                val lshift : t -> t -> t
                val rshift : t -> t -> t
                val arshift : t -> t -> t
                val ( ~- ) : t -> t
                val ( + ) : t -> t -> t
                val ( - ) : t -> t -> t
                val ( * ) : t -> t -> t
                val ( / ) : t -> t -> t
                val ( mod ) : t -> t -> t
                val ( land ) : t -> t -> t
                val ( lor ) : t -> t -> t
                val ( lxor ) : t -> t -> t
                val ( lsl ) : t -> t -> t
                val ( lsr ) : t -> t -> t
                val ( asr ) : t -> t -> t
              end
        end
      module Legacy :
        sig
          module Monad :
            sig
              module type Basic = Core_kernel.Std.Monad.Basic
              module type Basic2 = Core_kernel.Std.Monad.Basic2
              module type Infix = Core_kernel.Std.Monad.Infix
              module type Infix2 = Core_kernel.Std.Monad.Infix2
              module type S = Core_kernel.Std.Monad.S
              module type S2 = Core_kernel.Std.Monad.S2
              module Make :
                functor (M : Basic->
                  sig
                    val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                    val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                    module Monad_infix :
                      sig
                        val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                        val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                      end
                    val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                    val return : '-> 'M.t
                    val map : 'M.t -> f:('-> 'b) -> 'M.t
                    val join : 'M.t M.t -> 'M.t
                    val ignore_m : 'M.t -> unit M.t
                    val all : 'M.t list -> 'a list M.t
                    val all_ignore : unit M.t list -> unit M.t
                    module Let_syntax :
                      sig
                        val return : '-> 'M.t
                        val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                        val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                        module Let_syntax :
                          sig
                            val return : '-> 'M.t
                            val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                            val map : 'M.t -> f:('-> 'b) -> 'M.t
                            val both : 'M.t -> 'M.t -> ('a * 'b) M.t
                            module Open_on_rhs : sig  end
                          end
                      end
                  end
              module Make2 :
                functor (M : Basic2->
                  sig
                    val ( >>= ) :
                      ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) M.t
                        val ( >>= ) :
                          ('a, 'e) M.t ->
                          ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val ( >>| ) :
                          ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) M.t
                            val bind :
                              ('a, 'e) M.t ->
                              f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                            val map :
                              ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                            val both :
                              ('a, 'e) M.t ->
                              ('b, 'e) M.t -> ('a * 'b, 'e) M.t
                            module Open_on_rhs : sig  end
                          end
                      end
                    module Monad_infix :
                      sig
                        val ( >>= ) :
                          ('a, 'e) M.t ->
                          ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val ( >>| ) :
                          ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                      end
                    val bind :
                      ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val return : '-> ('a, 'b) M.t
                    val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                    val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
                    val ignore_m : ('a, 'e) M.t -> (unit, 'e) M.t
                    val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
                    val all_ignore : (unit, 'e) M.t list -> (unit, 'e) M.t
                  end
              module State :
                sig
                  module type S =
                    sig
                      type ('a, 's) t
                      type 'a result
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val ( >>= ) :
                            ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                          val ( >>| ) :
                            ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          module Let_syntax :
                            sig
                              val return : '-> ('a, 'b) t
                              val bind :
                                ('a, 'e) t ->
                                f:('-> ('b, 'e) t) -> ('b, 'e) t
                              val map :
                                ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                              val both :
                                ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                              module Open_on_rhs : sig  end
                            end
                        end
                      module Monad_infix :
                        sig
                          val ( >>= ) :
                            ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                          val ( >>| ) :
                            ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        end
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val return : '-> ('a, 'b) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                      val ignore_m : ('a, 'e) t -> (unit, 'e) t
                      val all : ('a, 'e) t list -> ('a list, 'e) t
                      val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                      val put :
                        '-> (unit, 's) Bap.Std.Legacy.Monad.State.S.t
                      val get :
                        unit -> ('s, 's) Bap.Std.Legacy.Monad.State.S.t
                      val gets :
                        ('-> 'r) -> ('r, 's) Bap.Std.Legacy.Monad.State.S.t
                      val update :
                        ('-> 's) ->
                        (unit, 's) Bap.Std.Legacy.Monad.State.S.t
                      val modify :
                        ('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
                        ('-> 's) -> ('a, 's) Bap.Std.Legacy.Monad.State.S.t
                      val run :
                        ('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
                        '-> ('a * 's) Bap.Std.Legacy.Monad.State.S.result
                      val eval :
                        ('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
                        '-> 'Bap.Std.Legacy.Monad.State.S.result
                      val exec :
                        ('a, 's) Bap.Std.Legacy.Monad.State.S.t ->
                        '-> 'Bap.Std.Legacy.Monad.State.S.result
                    end
                  type ('a, 'e) t = ('a, 'e) Monads.Std.Monad.State.t
                  type 'a result = 'a
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (unit, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                  val put : '-> (unit, 's) t
                  val get : unit -> ('s, 's) t
                  val gets : ('-> 'r) -> ('r, 's) t
                  val update : ('-> 's) -> (unit, 's) t
                  val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
                  val run : ('a, 's) t -> '-> 'a * 's
                  val eval : ('a, 's) t -> '-> 'a
                  val exec : ('a, 's) t -> '-> 's
                end
              module T :
                sig
                  module Option :
                    sig
                      module Make :
                        functor (M : S->
                          sig
                            type 'a t = 'a option M.t
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                            module Monad_infix :
                              sig
                                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                              end
                            val bind : 'a t -> f:('-> 'b t) -> 'b t
                            val return : '-> 'a t
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val join : 'a t t -> 'a t
                            val ignore_m : 'a t -> unit t
                            val all : 'a t list -> 'a list t
                            val all_ignore : unit t list -> unit t
                            module Let_syntax :
                              sig
                                val return : '-> 'a t
                                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                                module Let_syntax :
                                  sig
                                    val return : '-> 'a t
                                    val bind : 'a t -> f:('-> 'b t) -> 'b t
                                    val map : 'a t -> f:('-> 'b) -> 'b t
                                    val both : 'a t -> 'b t -> ('a * 'b) t
                                    module Open_on_rhs : sig  end
                                  end
                              end
                          end
                      module Make2 :
                        functor (M : S2->
                          sig
                            type ('a, 'b) t = ('a option, 'b) M.t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val ( >>= ) :
                                  ('a, 'e) t ->
                                  ('-> ('b, 'e) t) -> ('b, 'e) t
                                val ( >>| ) :
                                  ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                                module Let_syntax :
                                  sig
                                    val return : '-> ('a, 'b) t
                                    val bind :
                                      ('a, 'e) t ->
                                      f:('-> ('b, 'e) t) -> ('b, 'e) t
                                    val map :
                                      ('a, 'e) t ->
                                      f:('-> 'b) -> ('b, 'e) t
                                    val both :
                                      ('a, 'e) t ->
                                      ('b, 'e) t -> ('a * 'b, 'e) t
                                    module Open_on_rhs : sig  end
                                  end
                              end
                            module Monad_infix :
                              sig
                                val ( >>= ) :
                                  ('a, 'e) t ->
                                  ('-> ('b, 'e) t) -> ('b, 'e) t
                                val ( >>| ) :
                                  ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                              end
                            val bind :
                              ('a, 'e) t ->
                              f:('-> ('b, 'e) t) -> ('b, 'e) t
                            val return : '-> ('a, 'b) t
                            val map :
                              ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                            val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                            val ignore_m : ('a, 'e) t -> (unit, 'e) t
                            val all : ('a, 'e) t list -> ('a list, 'e) t
                            val all_ignore :
                              (unit, 'e) t list -> (unit, 'e) t
                          end
                    end
                  module Or_error :
                    sig
                      module Make :
                        functor (M : S->
                          sig
                            type 'a t = 'Core_kernel.Std.Or_error.t M.t
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                            module Monad_infix :
                              sig
                                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                              end
                            val bind : 'a t -> f:('-> 'b t) -> 'b t
                            val return : '-> 'a t
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val join : 'a t t -> 'a t
                            val ignore_m : 'a t -> unit t
                            val all : 'a t list -> 'a list t
                            val all_ignore : unit t list -> unit t
                            module Let_syntax :
                              sig
                                val return : '-> 'a t
                                val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                                val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                                module Let_syntax :
                                  sig
                                    val return : '-> 'a t
                                    val bind : 'a t -> f:('-> 'b t) -> 'b t
                                    val map : 'a t -> f:('-> 'b) -> 'b t
                                    val both : 'a t -> 'b t -> ('a * 'b) t
                                    module Open_on_rhs : sig  end
                                  end
                              end
                          end
                      module Make2 :
                        functor (M : S2->
                          sig
                            type ('a, 'b) t =
                                ('Core_kernel.Std.Or_error.t, 'b) M.t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val ( >>= ) :
                                  ('a, 'e) t ->
                                  ('-> ('b, 'e) t) -> ('b, 'e) t
                                val ( >>| ) :
                                  ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                                module Let_syntax :
                                  sig
                                    val return : '-> ('a, 'b) t
                                    val bind :
                                      ('a, 'e) t ->
                                      f:('-> ('b, 'e) t) -> ('b, 'e) t
                                    val map :
                                      ('a, 'e) t ->
                                      f:('-> 'b) -> ('b, 'e) t
                                    val both :
                                      ('a, 'e) t ->
                                      ('b, 'e) t -> ('a * 'b, 'e) t
                                    module Open_on_rhs : sig  end
                                  end
                              end
                            module Monad_infix :
                              sig
                                val ( >>= ) :
                                  ('a, 'e) t ->
                                  ('-> ('b, 'e) t) -> ('b, 'e) t
                                val ( >>| ) :
                                  ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                              end
                            val bind :
                              ('a, 'e) t ->
                              f:('-> ('b, 'e) t) -> ('b, 'e) t
                            val return : '-> ('a, 'b) t
                            val map :
                              ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                            val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                            val ignore_m : ('a, 'e) t -> (unit, 'e) t
                            val all : ('a, 'e) t list -> ('a list, 'e) t
                            val all_ignore :
                              (unit, 'e) t list -> (unit, 'e) t
                          end
                    end
                  module Result :
                    sig
                      module Make :
                        functor (M : S->
                          sig
                            type ('a, 'e) t =
                                ('a, 'e) Core_kernel.Std.Result.t M.t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val ( >>= ) :
                                  ('a, 'e) t ->
                                  ('-> ('b, 'e) t) -> ('b, 'e) t
                                val ( >>| ) :
                                  ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                                module Let_syntax :
                                  sig
                                    val return : '-> ('a, 'b) t
                                    val bind :
                                      ('a, 'e) t ->
                                      f:('-> ('b, 'e) t) -> ('b, 'e) t
                                    val map :
                                      ('a, 'e) t ->
                                      f:('-> 'b) -> ('b, 'e) t
                                    val both :
                                      ('a, 'e) t ->
                                      ('b, 'e) t -> ('a * 'b, 'e) t
                                    module Open_on_rhs : sig  end
                                  end
                              end
                            module Monad_infix :
                              sig
                                val ( >>= ) :
                                  ('a, 'e) t ->
                                  ('-> ('b, 'e) t) -> ('b, 'e) t
                                val ( >>| ) :
                                  ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                              end
                            val bind :
                              ('a, 'e) t ->
                              f:('-> ('b, 'e) t) -> ('b, 'e) t
                            val return : '-> ('a, 'b) t
                            val map :
                              ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                            val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                            val ignore_m : ('a, 'e) t -> (unit, 'e) t
                            val all : ('a, 'e) t list -> ('a list, 'e) t
                            val all_ignore :
                              (unit, 'e) t list -> (unit, 'e) t
                          end
                    end
                  module State :
                    sig
                      module Make :
                        functor (M : S->
                          sig
                            type ('a, 's) t
                            type 'a result = 'M.t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val ( >>= ) :
                                  ('a, 'e) t ->
                                  ('-> ('b, 'e) t) -> ('b, 'e) t
                                val ( >>| ) :
                                  ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                                module Let_syntax :
                                  sig
                                    val return : '-> ('a, 'b) t
                                    val bind :
                                      ('a, 'e) t ->
                                      f:('-> ('b, 'e) t) -> ('b, 'e) t
                                    val map :
                                      ('a, 'e) t ->
                                      f:('-> 'b) -> ('b, 'e) t
                                    val both :
                                      ('a, 'e) t ->
                                      ('b, 'e) t -> ('a * 'b, 'e) t
                                    module Open_on_rhs : sig  end
                                  end
                              end
                            module Monad_infix :
                              sig
                                val ( >>= ) :
                                  ('a, 'e) t ->
                                  ('-> ('b, 'e) t) -> ('b, 'e) t
                                val ( >>| ) :
                                  ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                              end
                            val bind :
                              ('a, 'e) t ->
                              f:('-> ('b, 'e) t) -> ('b, 'e) t
                            val return : '-> ('a, 'b) t
                            val map :
                              ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                            val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                            val ignore_m : ('a, 'e) t -> (unit, 'e) t
                            val all : ('a, 'e) t list -> ('a list, 'e) t
                            val all_ignore :
                              (unit, 'e) t list -> (unit, 'e) t
                            val put : '-> (unit, 's) t
                            val get : unit -> ('s, 's) t
                            val gets : ('-> 'r) -> ('r, 's) t
                            val update : ('-> 's) -> (unit, 's) t
                            val modify :
                              ('a, 's) t -> ('-> 's) -> ('a, 's) t
                            val run : ('a, 's) t -> '-> ('a * 's) result
                            val eval : ('a, 's) t -> '-> 'a result
                            val exec : ('a, 's) t -> '-> 's result
                          end
                    end
                end
            end
        end
      module Seq :
        sig
          type 'a t = 'Core_kernel.Std.Sequence.t
          val bin_t :
            'Core_kernel.Std.Bin_prot.Type_class.t ->
            'a t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t :
            'Core_kernel.Std.Bin_prot.Read.reader ->
            'a t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            'Core_kernel.Std.Bin_prot.Read.reader ->
            (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t :
            'Core_kernel.Std.Bin_prot.Type_class.reader ->
            'a t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t :
            'Core_kernel.Std.Bin_prot.Size.sizer ->
            'a t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t :
            'Core_kernel.Std.Bin_prot.Write.writer ->
            'a t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t :
            'Core_kernel.Std.Bin_prot.Type_class.writer ->
            'a t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t :
            Core_kernel.Std.Bin_prot.Shape.t ->
            Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          module Merge_with_duplicates_element :
            sig
              type ('a, 'b) t =
                ('a, 'b) Base.Sequence.Merge_with_duplicates_element.t =
                  Left of 'a
                | Right of 'b
                | Both of 'a * 'b
              val bin_t :
                'Bin_prot.Type_class.t ->
                'Bin_prot.Type_class.t -> ('a, 'b) t Bin_prot.Type_class.t
              val bin_read_t :
                'Bin_prot.Read.reader ->
                'Bin_prot.Read.reader -> ('a, 'b) t Bin_prot.Read.reader
              val __bin_read_t__ :
                'Bin_prot.Read.reader ->
                'Bin_prot.Read.reader ->
                (int -> ('a, 'b) t) Bin_prot.Read.reader
              val bin_reader_t :
                'Bin_prot.Type_class.reader ->
                'Bin_prot.Type_class.reader ->
                ('a, 'b) t Bin_prot.Type_class.reader
              val bin_size_t :
                'Bin_prot.Size.sizer ->
                'Bin_prot.Size.sizer -> ('a, 'b) t Bin_prot.Size.sizer
              val bin_write_t :
                'Bin_prot.Write.writer ->
                'Bin_prot.Write.writer -> ('a, 'b) t Bin_prot.Write.writer
              val bin_writer_t :
                'Bin_prot.Type_class.writer ->
                'Bin_prot.Type_class.writer ->
                ('a, 'b) t Bin_prot.Type_class.writer
              val bin_shape_t :
                Bin_prot.Shape.t -> Bin_prot.Shape.t -> Bin_prot.Shape.t
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                (Base__.Sexplib.Sexp.t -> 'b) ->
                Base__.Sexplib.Sexp.t -> ('a, 'b) t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                ('-> Base__.Sexplib.Sexp.t) ->
                ('a, 'b) t -> Base__.Sexplib.Sexp.t
              val hash_fold_t :
                (Base__.Ppx_hash_lib.Std.Hash.state ->
                 '-> Base__.Ppx_hash_lib.Std.Hash.state) ->
                (Base__.Ppx_hash_lib.Std.Hash.state ->
                 '-> Base__.Ppx_hash_lib.Std.Hash.state) ->
                Base__.Ppx_hash_lib.Std.Hash.state ->
                ('a, 'b) t -> Base__.Ppx_hash_lib.Std.Hash.state
              val compare :
                ('-> '-> int) ->
                ('-> '-> int) -> ('a, 'b) t -> ('a, 'b) t -> int
            end
          val sexp_of_t :
            ('-> Base__.Sexplib.Sexp.t) -> 'a t -> Base__.Sexplib.Sexp.t
          type 'a sequence = 'a t
          val mem : 'a sequence -> '-> equal:('-> '-> bool) -> bool
          val length : 'a sequence -> int
          val iter : 'a sequence -> f:('-> unit) -> unit
          val fold :
            'a sequence ->
            init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a sequence ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a sequence ->
            init:'accum ->
            f:('accum ->
               '-> ('accum, 'stop) Base__.Container_intf.Continue_or_stop.t) ->
            ('accum, 'stop) Base__.Container_intf.Finished_or_stopped_early.t
          val exists : 'a sequence -> f:('-> bool) -> bool
          val for_all : 'a sequence -> f:('-> bool) -> bool
          val count : 'a sequence -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a sequence -> f:('-> 'sum) -> 'sum
          val find : 'a sequence -> f:('-> bool) -> 'a option
          val find_map : 'a sequence -> f:('-> 'b option) -> 'b option
          val to_array : 'a sequence -> 'a array
          val min_elt : 'a sequence -> cmp:('-> '-> int) -> 'a option
          val max_elt : 'a sequence -> cmp:('-> '-> int) -> 'a option
          val ( >>= ) : 'a sequence -> ('-> 'b sequence) -> 'b sequence
          val ( >>| ) : 'a sequence -> ('-> 'b) -> 'b sequence
          module Monad_infix :
            sig
              val ( >>= ) :
                'Base__Sequence.t ->
                ('-> 'Base__Sequence.t) -> 'Base__Sequence.t
              val ( >>| ) :
                'Base__Sequence.t -> ('-> 'b) -> 'Base__Sequence.t
            end
          val bind : 'a sequence -> f:('-> 'b sequence) -> 'b sequence
          val return : '-> 'a sequence
          val map : 'a sequence -> f:('-> 'b) -> 'b sequence
          val join : 'a sequence sequence -> 'a sequence
          val ignore_m : 'a sequence -> unit sequence
          val all : 'a sequence list -> 'a list sequence
          val all_ignore : unit sequence list -> unit sequence
          module Let_syntax :
            sig
              val return : '-> 'Base__Sequence.t
              val ( >>= ) :
                'Base__Sequence.t ->
                ('-> 'Base__Sequence.t) -> 'Base__Sequence.t
              val ( >>| ) :
                'Base__Sequence.t -> ('-> 'b) -> 'Base__Sequence.t
              module Let_syntax :
                sig
                  val return : '-> 'Base__Sequence.t
                  val bind :
                    'Base__Sequence.t ->
                    f:('-> 'Base__Sequence.t) -> 'Base__Sequence.t
                  val map :
                    'Base__Sequence.t ->
                    f:('-> 'b) -> 'Base__Sequence.t
                  val both :
                    'Base__Sequence.t ->
                    'Base__Sequence.t -> ('a * 'b) Base__Sequence.t
                  module Open_on_rhs : sig  end
                end
            end
          val empty : 'a sequence
          val next : 'a sequence -> ('a * 'a sequence) option
          module Step :
            sig
              type ('a, 's) t =
                ('a, 's) Base__Sequence.Step.t =
                  Done
                | Skip of 's
                | Yield of 'a * 's
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                ('-> Base__.Sexplib.Sexp.t) ->
                ('a, 's) t -> Base__.Sexplib.Sexp.t
            end
          val unfold_step :
            init:'-> f:('-> ('a, 's) Step.t) -> 'a sequence
          val unfold : init:'-> f:('-> ('a * 's) option) -> 'a sequence
          val unfold_with :
            'a sequence ->
            init:'-> f:('-> '-> ('b, 's) Step.t) -> 'b sequence
          val unfold_with_and_finish :
            'a sequence ->
            init:'s_a ->
            running_step:('s_a -> '-> ('b, 's_a) Step.t) ->
            inner_finished:('s_a -> 's_b) ->
            finishing_step:('s_b -> ('b, 's_b) Step.t) -> 'b sequence
          val nth : 'a sequence -> int -> 'a option
          val nth_exn : 'a sequence -> int -> 'a
          val mapi : 'a sequence -> f:(int -> '-> 'b) -> 'b sequence
          val filteri : 'a sequence -> f:(int -> '-> bool) -> 'a sequence
          val merge :
            'a sequence ->
            'a sequence -> cmp:('-> '-> int) -> 'a sequence
          val merge_with_duplicates :
            'a sequence ->
            'b sequence ->
            cmp:('-> '-> int) ->
            ('a, 'b) Merge_with_duplicates_element.t sequence
          val hd : 'a sequence -> 'a option
          val hd_exn : 'a sequence -> 'a
          val tl : 'a sequence -> 'a sequence option
          val tl_eagerly_exn : 'a sequence -> 'a sequence
          val find_mapi :
            'a sequence -> f:(int -> '-> 'b option) -> 'b option
          val findi :
            'a sequence -> f:(int -> '-> bool) -> (int * 'a) option
          val find_exn : 'a sequence -> f:('-> bool) -> 'a
          val for_alli : 'a sequence -> f:(int -> '-> bool) -> bool
          val existsi : 'a sequence -> f:(int -> '-> bool) -> bool
          val append : 'a sequence -> 'a sequence -> 'a sequence
          val concat : 'a sequence sequence -> 'a sequence
          val concat_map :
            'a sequence -> f:('-> 'b sequence) -> 'b sequence
          val concat_mapi :
            'a sequence -> f:(int -> '-> 'b sequence) -> 'b sequence
          val interleave : 'a sequence sequence -> 'a sequence
          val zip : 'a sequence -> 'b sequence -> ('a * 'b) sequence
          val zip_full :
            'a sequence ->
            'b sequence ->
            [ `Both of 'a * '| `Left of '| `Right of 'b ] sequence
          val iteri : 'a sequence -> f:(int -> '-> unit) -> unit
          val foldi :
            'a sequence -> f:(int -> '-> '-> 'b) -> init:'-> 'b
          val reduce_exn : 'a sequence -> f:('-> '-> 'a) -> 'a
          val reduce : 'a sequence -> f:('-> '-> 'a) -> 'a option
          val find_consecutive_duplicate :
            'a sequence -> equal:('-> '-> bool) -> ('a * 'a) option
          val remove_consecutive_duplicates :
            'a sequence -> equal:('-> '-> bool) -> 'a sequence
          val range :
            ?stride:int ->
            ?start:[ `exclusive | `inclusive ] ->
            ?stop:[ `exclusive | `inclusive ] -> int -> int -> int sequence
          val init : int -> f:(int -> 'a) -> 'a sequence
          val filter_map : 'a sequence -> f:('-> 'b option) -> 'b sequence
          val filter_mapi :
            'a sequence -> f:(int -> '-> 'b option) -> 'b sequence
          val filter_opt : 'a option sequence -> 'a sequence
          val sub : 'a sequence -> pos:int -> len:int -> 'a sequence
          val take : 'a sequence -> int -> 'a sequence
          val drop : 'a sequence -> int -> 'a sequence
          val drop_eagerly : 'a sequence -> int -> 'a sequence
          val take_while : 'a sequence -> f:('-> bool) -> 'a sequence
          val drop_while : 'a sequence -> f:('-> bool) -> 'a sequence
          val drop_while_option :
            'a sequence -> f:('-> bool) -> ('a * 'a sequence) option
          val split_n : 'a sequence -> int -> 'a list * 'a sequence
          val split_n_eagerly :
            'a sequence -> int -> 'a sequence * 'a sequence
          val chunks_exn : 'a sequence -> int -> 'a list sequence
          val shift_right : 'a sequence -> '-> 'a sequence
          val shift_right_with_list : 'a sequence -> 'a list -> 'a sequence
          val shift_left : 'a sequence -> int -> 'a sequence
          module Infix :
            sig
              val ( @ ) :
                'Base__Sequence.t ->
                'Base__Sequence.t -> 'Base__Sequence.t
            end
          val cartesian_product :
            'a sequence -> 'b sequence -> ('a * 'b) sequence
          val interleaved_cartesian_product :
            'a sequence -> 'b sequence -> ('a * 'b) sequence
          val intersperse : 'a sequence -> sep:'-> 'a sequence
          val cycle_list_exn : 'a list -> 'a sequence
          val repeat : '-> 'a sequence
          val singleton : '-> 'a sequence
          val delayed_fold :
            'a sequence ->
            init:'->
            f:('-> '-> k:('-> 'r) -> 'r) -> finish:('-> 'r) -> 'r
          val to_list : 'a sequence -> 'a list
          val to_list_rev : 'a sequence -> 'a list
          val of_list : 'a list -> 'a sequence
          val of_lazy : 'a sequence Base__.Lazy.t -> 'a sequence
          val memoize : 'a sequence -> 'a sequence
          val force_eagerly : 'a sequence -> 'a sequence
          val bounded_length :
            'a sequence -> at_most:int -> [ `Greater | `Is of int ]
          val length_is_bounded_by :
            ?min:int -> ?max:int -> 'a sequence -> bool
          module Generator :
            sig
              type ('a, 'e) t = ('a, 'e) Base__Sequence.Generator.t
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (unit, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore : (unit, 'e) t list -> (unit, 'e) t
              val yield : 'elt -> (unit, 'elt) t
              val of_sequence :
                'elt Base__Sequence.sequence -> (unit, 'elt) t
              val run : (unit, 'elt) t -> 'elt Base__Sequence.sequence
            end
          val filter : 'a sequence -> f:('-> bool) -> 'a sequence
          val compare :
            ('-> '-> int) -> 'a sequence -> 'b sequence -> int
          val of_array : 'a array -> 'a sequence
          val cons : '-> 'a sequence -> 'a sequence
          val is_empty : 'a sequence -> bool
          val pp : 'Regular.Std.printer -> 'a sequence Regular.Std.printer
        end
      type 'a seq = 'Bap.Std.Seq.t
      val bin_seq :
        'Core_kernel.Std.Bin_prot.Type_class.t ->
        'a seq Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_seq :
        'Core_kernel.Std.Bin_prot.Read.reader ->
        'a seq Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_seq__ :
        'Core_kernel.Std.Bin_prot.Read.reader ->
        (int -> 'a seq) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_seq :
        'Core_kernel.Std.Bin_prot.Type_class.reader ->
        'a seq Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_seq :
        'Core_kernel.Std.Bin_prot.Size.sizer ->
        'a seq Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_seq :
        'Core_kernel.Std.Bin_prot.Write.writer ->
        'a seq Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_seq :
        'Core_kernel.Std.Bin_prot.Type_class.writer ->
        'a seq Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_seq :
        Core_kernel.Std.Bin_prot.Shape.t -> Core_kernel.Std.Bin_prot.Shape.t
      val compare_seq : ('-> '-> int) -> 'a seq -> 'a seq -> int
      val seq_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a seq
      val sexp_of_seq : ('-> Sexplib.Sexp.t) -> 'a seq -> Sexplib.Sexp.t
      module Trie :
        sig
          module type Key =
            sig
              type t
              type token
              val bin_token : token Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_token : token Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_token__ :
                (int -> token) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_token :
                token Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_token : token Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_token :
                token Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_token :
                token Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_token : Core_kernel.Std.Bin_prot.Shape.t
              val compare_token : token -> token -> int
              val token_of_sexp : Sexplib.Sexp.t -> token
              val sexp_of_token : token -> Sexplib.Sexp.t
              val length : Bap.Std.Trie.Key.t -> int
              val nth_token :
                Bap.Std.Trie.Key.t -> int -> Bap.Std.Trie.Key.token
              val token_hash : Bap.Std.Trie.Key.token -> int
            end
          module type S =
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Std.Bin_prot.Type_class.t ->
                'a t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Std.Bin_prot.Read.reader ->
                'a t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Std.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Std.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Std.Bin_prot.Size.sizer ->
                'a t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Std.Bin_prot.Write.writer ->
                'a t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Std.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Std.Bin_prot.Shape.t ->
                Core_kernel.Std.Bin_prot.Shape.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              type key
              val create : unit -> 'Bap.Std.Trie.S.t
              val add :
                'Bap.Std.Trie.S.t ->
                key:Bap.Std.Trie.S.key -> data:'-> unit
              val change :
                'Bap.Std.Trie.S.t ->
                Bap.Std.Trie.S.key -> ('a option -> 'a option) -> unit
              val find :
                'Bap.Std.Trie.S.t -> Bap.Std.Trie.S.key -> 'a option
              val walk :
                'Bap.Std.Trie.S.t ->
                Bap.Std.Trie.S.key ->
                init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'Bap.Std.Trie.S.t -> Bap.Std.Trie.S.key -> unit
              val longest_match :
                'Bap.Std.Trie.S.t ->
                Bap.Std.Trie.S.key -> (int * 'a) option
              val length : 'Bap.Std.Trie.S.t -> int
              val pp :
                'Regular.Std.printer ->
                'Bap.Std.Trie.S.t Regular.Std.printer
            end
          module Make :
            functor (Key : Key->
              sig
                type 'a t
                val bin_t :
                  'Core_kernel.Std.Bin_prot.Type_class.t ->
                  'a t Core_kernel.Std.Bin_prot.Type_class.t
                val bin_read_t :
                  'Core_kernel.Std.Bin_prot.Read.reader ->
                  'a t Core_kernel.Std.Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Core_kernel.Std.Bin_prot.Read.reader ->
                  (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                val bin_reader_t :
                  'Core_kernel.Std.Bin_prot.Type_class.reader ->
                  'a t Core_kernel.Std.Bin_prot.Type_class.reader
                val bin_size_t :
                  'Core_kernel.Std.Bin_prot.Size.sizer ->
                  'a t Core_kernel.Std.Bin_prot.Size.sizer
                val bin_write_t :
                  'Core_kernel.Std.Bin_prot.Write.writer ->
                  'a t Core_kernel.Std.Bin_prot.Write.writer
                val bin_writer_t :
                  'Core_kernel.Std.Bin_prot.Type_class.writer ->
                  'a t Core_kernel.Std.Bin_prot.Type_class.writer
                val bin_shape_t :
                  Core_kernel.Std.Bin_prot.Shape.t ->
                  Core_kernel.Std.Bin_prot.Shape.t
                val t_of_sexp :
                  (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                type key = Key.t
                val create : unit -> 'a t
                val add : 'a t -> key:key -> data:'-> unit
                val change : 'a t -> key -> ('a option -> 'a option) -> unit
                val find : 'a t -> key -> 'a option
                val walk :
                  'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                val remove : 'a t -> key -> unit
                val longest_match : 'a t -> key -> (int * 'a) option
                val length : 'a t -> int
                val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
              end
          module type Token =
            sig
              type t
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val hash : Bap.Std.Trie.Token.t -> int
            end
          module Array :
            sig
              module Prefix :
                functor (Tok : Token->
                  sig
                    type 'a t
                    val bin_t :
                      'Core_kernel.Std.Bin_prot.Type_class.t ->
                      'a t Core_kernel.Std.Bin_prot.Type_class.t
                    val bin_read_t :
                      'Core_kernel.Std.Bin_prot.Read.reader ->
                      'a t Core_kernel.Std.Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Core_kernel.Std.Bin_prot.Read.reader ->
                      (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                    val bin_reader_t :
                      'Core_kernel.Std.Bin_prot.Type_class.reader ->
                      'a t Core_kernel.Std.Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Core_kernel.Std.Bin_prot.Size.sizer ->
                      'a t Core_kernel.Std.Bin_prot.Size.sizer
                    val bin_write_t :
                      'Core_kernel.Std.Bin_prot.Write.writer ->
                      'a t Core_kernel.Std.Bin_prot.Write.writer
                    val bin_writer_t :
                      'Core_kernel.Std.Bin_prot.Type_class.writer ->
                      'a t Core_kernel.Std.Bin_prot.Type_class.writer
                    val bin_shape_t :
                      Core_kernel.Std.Bin_prot.Shape.t ->
                      Core_kernel.Std.Bin_prot.Shape.t
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    type key = Tok.t array
                    val create : unit -> 'a t
                    val add : 'a t -> key:key -> data:'-> unit
                    val change :
                      'a t -> key -> ('a option -> 'a option) -> unit
                    val find : 'a t -> key -> 'a option
                    val walk :
                      'a t ->
                      key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                    val remove : 'a t -> key -> unit
                    val longest_match : 'a t -> key -> (int * 'a) option
                    val length : 'a t -> int
                    val pp :
                      'Regular.Std.printer -> 'a t Regular.Std.printer
                  end
              module Suffix :
                functor (Tok : Token->
                  sig
                    type 'a t
                    val bin_t :
                      'Core_kernel.Std.Bin_prot.Type_class.t ->
                      'a t Core_kernel.Std.Bin_prot.Type_class.t
                    val bin_read_t :
                      'Core_kernel.Std.Bin_prot.Read.reader ->
                      'a t Core_kernel.Std.Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Core_kernel.Std.Bin_prot.Read.reader ->
                      (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                    val bin_reader_t :
                      'Core_kernel.Std.Bin_prot.Type_class.reader ->
                      'a t Core_kernel.Std.Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Core_kernel.Std.Bin_prot.Size.sizer ->
                      'a t Core_kernel.Std.Bin_prot.Size.sizer
                    val bin_write_t :
                      'Core_kernel.Std.Bin_prot.Write.writer ->
                      'a t Core_kernel.Std.Bin_prot.Write.writer
                    val bin_writer_t :
                      'Core_kernel.Std.Bin_prot.Type_class.writer ->
                      'a t Core_kernel.Std.Bin_prot.Type_class.writer
                    val bin_shape_t :
                      Core_kernel.Std.Bin_prot.Shape.t ->
                      Core_kernel.Std.Bin_prot.Shape.t
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    type key = Tok.t array
                    val create : unit -> 'a t
                    val add : 'a t -> key:key -> data:'-> unit
                    val change :
                      'a t -> key -> ('a option -> 'a option) -> unit
                    val find : 'a t -> key -> 'a option
                    val walk :
                      'a t ->
                      key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                    val remove : 'a t -> key -> unit
                    val longest_match : 'a t -> key -> (int * 'a) option
                    val length : 'a t -> int
                    val pp :
                      'Regular.Std.printer -> 'a t Regular.Std.printer
                  end
            end
          module String :
            sig
              module Prefix :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  type key = string
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module Suffix :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  type key = Prefix.key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
            end
        end
      module Interval_tree :
        sig
          module type Interval =
            sig
              type t
              val compare : t -> t -> int
              val sexp_of_t : t -> Sexplib.Sexp.t
              type point
              val compare_point : point -> point -> int
              val sexp_of_point : point -> Sexplib.Sexp.t
              val lower :
                Bap.Std.Interval_tree.Interval.t ->
                Bap.Std.Interval_tree.Interval.point
              val upper :
                Bap.Std.Interval_tree.Interval.t ->
                Bap.Std.Interval_tree.Interval.point
            end
          module type S =
            sig
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              type key
              type point
              val empty : 'Bap.Std.Interval_tree.S.t
              val singleton :
                Bap.Std.Interval_tree.S.key ->
                '-> 'Bap.Std.Interval_tree.S.t
              val least :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.point option
              val greatest :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.point option
              val min_binding :
                'Bap.Std.Interval_tree.S.t ->
                (Bap.Std.Interval_tree.S.key * 'a) option
              val max_binding :
                'Bap.Std.Interval_tree.S.t ->
                (Bap.Std.Interval_tree.S.key * 'a) option
              val add :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.key ->
                '-> 'Bap.Std.Interval_tree.S.t
              val dominators :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.key ->
                (Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Std.Sequence.t
              val intersections :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.key ->
                (Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Std.Sequence.t
              val intersects :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.key -> bool
              val dominates :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.key -> bool
              val contains :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.point -> bool
              val lookup :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.point ->
                (Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Std.Sequence.t
              val map :
                'Bap.Std.Interval_tree.S.t ->
                f:('-> 'b) -> 'Bap.Std.Interval_tree.S.t
              val mapi :
                'Bap.Std.Interval_tree.S.t ->
                f:(Bap.Std.Interval_tree.S.key -> '-> 'b) ->
                'Bap.Std.Interval_tree.S.t
              val filter :
                'Bap.Std.Interval_tree.S.t ->
                f:('-> bool) -> 'Bap.Std.Interval_tree.S.t
              val filter_map :
                'Bap.Std.Interval_tree.S.t ->
                f:('-> 'b option) -> 'Bap.Std.Interval_tree.S.t
              val filter_mapi :
                'Bap.Std.Interval_tree.S.t ->
                f:(Bap.Std.Interval_tree.S.key -> '-> 'b option) ->
                'Bap.Std.Interval_tree.S.t
              val remove :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.key -> 'Bap.Std.Interval_tree.S.t
              val remove_intersections :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.key -> 'Bap.Std.Interval_tree.S.t
              val remove_dominators :
                'Bap.Std.Interval_tree.S.t ->
                Bap.Std.Interval_tree.S.key -> 'Bap.Std.Interval_tree.S.t
              val to_sequence :
                'Bap.Std.Interval_tree.S.t ->
                (Bap.Std.Interval_tree.S.key * 'a) Core_kernel.Std.Sequence.t
              val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
            end
          module Make :
            functor (Interval : Interval->
              sig
                type 'a t
                val sexp_of_t :
                  ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                val empty : 'a t
                val singleton : Interval.t -> '-> 'a t
                val least : 'a t -> Interval.point option
                val greatest : 'a t -> Interval.point option
                val min_binding : 'a t -> (Interval.t * 'a) option
                val max_binding : 'a t -> (Interval.t * 'a) option
                val add : 'a t -> Interval.t -> '-> 'a t
                val dominators :
                  'a t -> Interval.t -> (Interval.t * 'a) Seq.t
                val intersections :
                  'a t -> Interval.t -> (Interval.t * 'a) Seq.t
                val intersects : 'a t -> Interval.t -> bool
                val dominates : 'a t -> Interval.t -> bool
                val contains : 'a t -> Interval.point -> bool
                val lookup :
                  'a t -> Interval.point -> (Interval.t * 'a) Seq.t
                val map : 'a t -> f:('-> 'b) -> 'b t
                val mapi : 'a t -> f:(Interval.t -> '-> 'b) -> 'b t
                val filter : 'a t -> f:('-> bool) -> 'a t
                val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(Interval.t -> '-> 'b option) -> 'b t
                val remove : 'a t -> Interval.t -> 'a t
                val remove_intersections : 'a t -> Interval.t -> 'a t
                val remove_dominators : 'a t -> Interval.t -> 'a t
                val to_sequence : 'a t -> (Interval.t * 'a) Seq.t
                val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('-> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     '->
                     ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                  ('accum, 'stop)
                  Base.Container_intf.Finished_or_stopped_early.t
                val exists : 'a t -> f:('-> bool) -> bool
                val for_all : 'a t -> f:('-> bool) -> bool
                val count : 'a t -> f:('-> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('-> 'sum) -> 'sum
                val find : 'a t -> f:('-> bool) -> 'a option
                val find_map : 'a t -> f:('-> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              end
          module type Interval_binable =
            sig
              type t
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val t_of_sexp : Sexplib.Sexp.t -> t
              type point
              val bin_point : point Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_point : point Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_point__ :
                (int -> point) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_point :
                point Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_point : point Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_point :
                point Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_point :
                point Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_point : Core_kernel.Std.Bin_prot.Shape.t
              val point_of_sexp : Sexplib.Sexp.t -> point
              val compare : t -> t -> int
              val sexp_of_t : t -> Sexplib.Sexp.t
              val compare_point : point -> point -> int
              val sexp_of_point : point -> Sexplib.Sexp.t
              val lower : t -> point
              val upper : t -> point
            end
          module type S_binable =
            sig
              type 'a t
              val bin_t :
                'Core_kernel.Std.Bin_prot.Type_class.t ->
                'a t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Std.Bin_prot.Read.reader ->
                'a t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Std.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Std.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Std.Bin_prot.Size.sizer ->
                'a t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Std.Bin_prot.Write.writer ->
                'a t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Std.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Std.Bin_prot.Shape.t ->
                Core_kernel.Std.Bin_prot.Shape.t
              val compare : ('-> '-> int) -> 'a t -> 'a t -> int
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              type key
              type point
              val empty : 'a t
              val singleton : key -> '-> 'a t
              val least : 'a t -> point option
              val greatest : 'a t -> point option
              val min_binding : 'a t -> (key * 'a) option
              val max_binding : 'a t -> (key * 'a) option
              val add : 'a t -> key -> '-> 'a t
              val dominators : 'a t -> key -> (key * 'a) Seq.t
              val intersections : 'a t -> key -> (key * 'a) Seq.t
              val intersects : 'a t -> key -> bool
              val dominates : 'a t -> key -> bool
              val contains : 'a t -> point -> bool
              val lookup : 'a t -> point -> (key * 'a) Seq.t
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key -> '-> 'b) -> 'b t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi : 'a t -> f:(key -> '-> 'b option) -> 'b t
              val remove : 'a t -> key -> 'a t
              val remove_intersections : 'a t -> key -> 'a t
              val remove_dominators : 'a t -> key -> 'a t
              val to_sequence : 'a t -> (key * 'a) Seq.t
              val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
            end
          module Make_binable :
            functor (Interval : Interval_binable->
              sig
                type 'a t
                val bin_t :
                  'Core_kernel.Std.Bin_prot.Type_class.t ->
                  'a t Core_kernel.Std.Bin_prot.Type_class.t
                val bin_read_t :
                  'Core_kernel.Std.Bin_prot.Read.reader ->
                  'a t Core_kernel.Std.Bin_prot.Read.reader
                val __bin_read_t__ :
                  'Core_kernel.Std.Bin_prot.Read.reader ->
                  (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                val bin_reader_t :
                  'Core_kernel.Std.Bin_prot.Type_class.reader ->
                  'a t Core_kernel.Std.Bin_prot.Type_class.reader
                val bin_size_t :
                  'Core_kernel.Std.Bin_prot.Size.sizer ->
                  'a t Core_kernel.Std.Bin_prot.Size.sizer
                val bin_write_t :
                  'Core_kernel.Std.Bin_prot.Write.writer ->
                  'a t Core_kernel.Std.Bin_prot.Write.writer
                val bin_writer_t :
                  'Core_kernel.Std.Bin_prot.Type_class.writer ->
                  'a t Core_kernel.Std.Bin_prot.Type_class.writer
                val bin_shape_t :
                  Core_kernel.Std.Bin_prot.Shape.t ->
                  Core_kernel.Std.Bin_prot.Shape.t
                val compare : ('-> '-> int) -> 'a t -> 'a t -> int
                val t_of_sexp :
                  (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                val sexp_of_t :
                  ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                val empty : 'a t
                val singleton : Interval.t -> '-> 'a t
                val least : 'a t -> Interval.point option
                val greatest : 'a t -> Interval.point option
                val min_binding : 'a t -> (Interval.t * 'a) option
                val max_binding : 'a t -> (Interval.t * 'a) option
                val add : 'a t -> Interval.t -> '-> 'a t
                val dominators :
                  'a t -> Interval.t -> (Interval.t * 'a) Seq.t
                val intersections :
                  'a t -> Interval.t -> (Interval.t * 'a) Seq.t
                val intersects : 'a t -> Interval.t -> bool
                val dominates : 'a t -> Interval.t -> bool
                val contains : 'a t -> Interval.point -> bool
                val lookup :
                  'a t -> Interval.point -> (Interval.t * 'a) Seq.t
                val map : 'a t -> f:('-> 'b) -> 'b t
                val mapi : 'a t -> f:(Interval.t -> '-> 'b) -> 'b t
                val filter : 'a t -> f:('-> bool) -> 'a t
                val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                val filter_mapi :
                  'a t -> f:(Interval.t -> '-> 'b option) -> 'b t
                val remove : 'a t -> Interval.t -> 'a t
                val remove_intersections : 'a t -> Interval.t -> 'a t
                val remove_dominators : 'a t -> Interval.t -> 'a t
                val to_sequence : 'a t -> (Interval.t * 'a) Seq.t
                val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
                val length : 'a t -> int
                val is_empty : 'a t -> bool
                val iter : 'a t -> f:('-> unit) -> unit
                val fold :
                  'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                val fold_result :
                  'a t ->
                  init:'accum ->
                  f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                  ('accum, 'e) Base__.Result.t
                val fold_until :
                  'a t ->
                  init:'accum ->
                  f:('accum ->
                     '->
                     ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                  ('accum, 'stop)
                  Base.Container_intf.Finished_or_stopped_early.t
                val exists : 'a t -> f:('-> bool) -> bool
                val for_all : 'a t -> f:('-> bool) -> bool
                val count : 'a t -> f:('-> bool) -> int
                val sum :
                  (module Base__.Commutative_group.S with type t = 'sum) ->
                  'a t -> f:('-> 'sum) -> 'sum
                val find : 'a t -> f:('-> bool) -> 'a option
                val find_map : 'a t -> f:('-> 'b option) -> 'b option
                val to_list : 'a t -> 'a list
                val to_array : 'a t -> 'a array
                val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              end
        end
      type value
      val bin_value : value Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_value : value Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_value__ :
        (int -> value) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_value : value Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_value : value Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_value : value Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_value : value Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_value : Core_kernel.Std.Bin_prot.Shape.t
      val compare_value : value -> value -> int
      val value_of_sexp : Sexplib.Sexp.t -> value
      val sexp_of_value : value -> Sexplib.Sexp.t
      type dict
      val bin_dict : dict Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_dict : dict Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_dict__ :
        (int -> dict) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_dict : dict Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_dict : dict Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_dict : dict Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_dict : dict Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_dict : Core_kernel.Std.Bin_prot.Shape.t
      val compare_dict : dict -> dict -> int
      val dict_of_sexp : Sexplib.Sexp.t -> dict
      val sexp_of_dict : dict -> Sexplib.Sexp.t
      type word
      val bin_word : word Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_word : word Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_word__ :
        (int -> word) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_word : word Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_word : word Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_word : word Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_word : word Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_word : Core_kernel.Std.Bin_prot.Shape.t
      val compare_word : word -> word -> int
      val word_of_sexp : Sexplib.Sexp.t -> word
      val sexp_of_word : word -> Sexplib.Sexp.t
      type addr = Bap.Std.word
      val bin_addr : addr Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_addr : addr Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_addr__ :
        (int -> addr) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_addr : addr Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_addr : addr Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_addr : addr Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_addr : addr Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_addr : Core_kernel.Std.Bin_prot.Shape.t
      val compare_addr : addr -> addr -> int
      val addr_of_sexp : Sexplib.Sexp.t -> addr
      val sexp_of_addr : addr -> Sexplib.Sexp.t
      module Size :
        sig
          type all = [ `r128 | `r16 | `r256 | `r32 | `r64 | `r8 ]
          val r8 : all
          val r16 : all
          val r32 : all
          val r64 : all
          val r128 : all
          val r256 : all
          module Variants_of_all :
            sig
              val r8 : all Variantslib.Variant.t
              val r16 : all Variantslib.Variant.t
              val r32 : all Variantslib.Variant.t
              val r64 : all Variantslib.Variant.t
              val r128 : all Variantslib.Variant.t
              val r256 : all Variantslib.Variant.t
              val fold :
                init:'acc__ ->
                r8:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
                r16:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
                r32:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
                r64:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
                r128:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
                r256:('acc__ -> all Variantslib.Variant.t -> 'acc__) ->
                'acc__
              val iter :
                r8:(all Variantslib.Variant.t -> unit) ->
                r16:(all Variantslib.Variant.t -> unit) ->
                r32:(all Variantslib.Variant.t -> unit) ->
                r64:(all Variantslib.Variant.t -> unit) ->
                r128:(all Variantslib.Variant.t -> unit) ->
                r256:(all Variantslib.Variant.t -> unit) -> unit
              val map :
                all ->
                r8:(all Variantslib.Variant.t -> 'result__) ->
                r16:(all Variantslib.Variant.t -> 'result__) ->
                r32:(all Variantslib.Variant.t -> 'result__) ->
                r64:(all Variantslib.Variant.t -> 'result__) ->
                r128:(all Variantslib.Variant.t -> 'result__) ->
                r256:(all Variantslib.Variant.t -> 'result__) -> 'result__
              val to_rank : all -> int
              val to_name : all -> Trie.String.Suffix.key
              val descriptions : (Trie.String.Suffix.key * int) list
            end
          type 'a p = 'constraint 'a = [< Bap.Std.Size.all ]
          val bin_p :
            ([< all ] as 'a) Core_kernel.Std.Bin_prot.Type_class.t ->
            'Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_p :
            ([< all ] as 'a) Core_kernel.Std.Bin_prot.Read.reader ->
            'Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_p__ :
            ([< all ] as 'a) Core_kernel.Std.Bin_prot.Read.reader ->
            (int -> 'a) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_p :
            ([< all ] as 'a) Core_kernel.Std.Bin_prot.Type_class.reader ->
            'Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_p :
            ([< all ] as 'a) Core_kernel.Std.Bin_prot.Size.sizer ->
            'Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_p :
            ([< all ] as 'a) Core_kernel.Std.Bin_prot.Write.writer ->
            'Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_p :
            ([< all ] as 'a) Core_kernel.Std.Bin_prot.Type_class.writer ->
            'Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_p :
            Core_kernel.Std.Bin_prot.Shape.t ->
            Core_kernel.Std.Bin_prot.Shape.t
          val compare_p : (([< all ] as 'a) -> '-> int) -> '-> '-> int
          val p_of_sexp :
            (Sexplib.Sexp.t -> ([< all ] as 'a)) -> Sexplib.Sexp.t -> 'a
          val sexp_of_p :
            (([< all ] as 'a) -> Sexplib.Sexp.t) -> '-> Sexplib.Sexp.t
          type t = Bap.Std.Size.all Bap.Std.Size.p
          val of_int : int -> Bap.Std.Size.t Core_kernel.Std.Or_error.t
          val of_int_exn : int -> Bap.Std.Size.t
          val of_int_opt : int -> Bap.Std.Size.t option
          val addr_of_int : int -> [ `r32 | `r64 ] Core_kernel.Std.Or_error.t
          val addr_of_int_exn : int -> [ `r32 | `r64 ]
          val addr_of_int_opt : int -> [ `r32 | `r64 ] option
          val addr_of_word_size :
            Core_kernel.Std.Word_size.t -> [ `r32 | `r64 ]
          val word_of_addr_size :
            [ `r32 | `r64 ] -> Core_kernel.Std.Word_size.t
          val to_addr_size :
            Bap.Std.Size.t -> [ `r32 | `r64 ] Core_kernel.Std.Or_error.t
          val in_bits : [< Bap.Std.Size.all ] Bap.Std.Size.p -> int
          val in_bytes : [< Bap.Std.Size.all ] Bap.Std.Size.p -> int
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl =
                  ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      type size = Bap.Std.Size.t
      val bin_size : size Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_size : size Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_size__ :
        (int -> size) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_size : size Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_size : size Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_size : size Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_size : size Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_size : Core_kernel.Std.Bin_prot.Shape.t
      val compare_size : size -> size -> int
      val size_of_sexp : Sexplib.Sexp.t -> size
      val sexp_of_size : size -> Sexplib.Sexp.t
      type addr_size = [ `r32 | `r64 ] Bap.Std.Size.p
      val bin_addr_size : addr_size Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_addr_size : addr_size Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_addr_size__ :
        (int -> addr_size) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_addr_size :
        addr_size Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_addr_size : addr_size Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_addr_size :
        addr_size Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_addr_size :
        addr_size Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_addr_size : Core_kernel.Std.Bin_prot.Shape.t
      val compare_addr_size : addr_size -> addr_size -> int
      val addr_size_of_sexp : Sexplib.Sexp.t -> addr_size
      val sexp_of_addr_size : addr_size -> Sexplib.Sexp.t
      module Bitvector :
        sig
          type t = Bap.Std.word
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.word
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Size.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
          module Mono :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = Hash_set.elt
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (Key.t, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : Key.t -> '-> 'a t
                      val of_alist :
                        (Key.t * 'a) list ->
                        [ `Duplicate_key of Key.t | `Ok of 'a t ]
                      val of_alist_or_error :
                        (Key.t * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (Key.t * 'a) list -> 'a t
                      val of_alist_multi : (Key.t * 'a) list -> 'a list t
                      val of_alist_fold :
                        (Key.t * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (Key.t * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (Key.t * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Key.t * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of Key.t | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        Key.t Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:Key.t -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:Key.t -> data:'-> 'a list t
                      val remove_multi : 'a list t -> Key.t -> 'a list t
                      val change :
                        'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> Key.t -> 'a option
                      val find_exn : 'a t -> Key.t -> 'a
                      val remove : 'a t -> Key.t -> 'a t
                      val mem : 'a t -> Key.t -> bool
                      val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:Key.t ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> Key.t list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (Key.t * 'a) list
                      val validate :
                        name:(Key.t -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (Key.t, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (Key.t * 'a) option
                      val min_elt_exn : 'a t -> Key.t * 'a
                      val max_elt : 'a t -> (Key.t * 'a) option
                      val max_elt_exn : 'a t -> Key.t * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> int
                      val split :
                        'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:Key.t Base__.Maybe_bound.t ->
                        upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:Key.t ->
                        max:Key.t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> Key.t -> (Key.t * 'a) option
                      val nth : 'a t -> int -> (Key.t * 'a) option
                      val nth_exn : 'a t -> int -> Key.t * 'a
                      val rank : 'a t -> Key.t -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:Key.t ->
                        ?keys_less_or_equal_to:Key.t ->
                        'a t -> (Key.t * 'a) Base__.Sequence.t
                      val obs :
                        Key.t Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : Key.t Bin_prot.Type_class.t
                               val bin_read_t : Key.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Key.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Key.t Bin_prot.Type_class.reader
                               val bin_size_t : Key.t Bin_prot.Size.sizer
                               val bin_write_t : Key.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Key.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Key.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = Hash_set.elt
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (Elt.t, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(Elt.t -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(Elt.t -> bool) -> bool
                      val for_all : t -> f:(Elt.t -> bool) -> bool
                      val count : t -> f:(Elt.t -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(Elt.t -> 'sum) -> 'sum
                      val find : t -> f:(Elt.t -> bool) -> Elt.t option
                      val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                      val to_list : t -> Elt.t list
                      val to_array : t -> Elt.t array
                      val invariants : t -> bool
                      val mem : t -> Elt.t -> bool
                      val add : t -> Elt.t -> t
                      val remove : t -> Elt.t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           Elt.t ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of Elt.t * Elt.t
                           | `Left of Elt.t
                           | `Right of Elt.t ] -> unit) ->
                        unit
                      val filter : t -> f:(Elt.t -> bool) -> t
                      val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                      val elements : t -> Elt.t list
                      val min_elt : t -> Elt.t option
                      val min_elt_exn : t -> Elt.t
                      val max_elt : t -> Elt.t option
                      val max_elt_exn : t -> Elt.t
                      val choose : t -> Elt.t option
                      val choose_exn : t -> Elt.t
                      val split : t -> Elt.t -> t * Elt.t option * t
                      val group_by :
                        t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                      val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                      val find_index : t -> int -> Elt.t option
                      val nth : t -> int -> Elt.t option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t -> Elt.t Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t ->
                        t ->
                        (Elt.t, Elt.t)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(Elt.t -> 'data) ->
                        (Elt.t, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        Elt.t Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : Elt.t -> t
                      val union_list : t list -> t
                      val of_list : Elt.t list -> t
                      val of_array : Elt.t array -> t
                      val of_sorted_array :
                        Elt.t array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : Elt.t array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Elt.t) -> t
                      val stable_dedup_list : Elt.t list -> Elt.t list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t option) -> t
                      val of_tree : t -> t
                      val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (Elt.t, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        Elt.t Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (Elt.t, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : Elt.t Bin_prot.Type_class.t
                               val bin_read_t : Elt.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Elt.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Elt.t Bin_prot.Type_class.reader
                               val bin_size_t : Elt.t Bin_prot.Size.sizer
                               val bin_write_t : Elt.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Elt.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Elt.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
            end
          type endian = LittleEndian | BigEndian
          val bin_endian : endian Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_endian : endian Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_endian__ :
            (int -> endian) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_endian :
            endian Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_endian : endian Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_endian : endian Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_endian :
            endian Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_endian : Core_kernel.Std.Bin_prot.Shape.t
          val compare_endian : endian -> endian -> int
          val endian_of_sexp : Sexplib.Sexp.t -> endian
          val sexp_of_endian : endian -> Sexplib.Sexp.t
          val of_string : string -> Bap.Std.Bitvector.t
          val of_bool : bool -> Bap.Std.Bitvector.t
          val of_int : width:int -> int -> Bap.Std.Bitvector.t
          val of_int32 : ?width:int -> int32 -> Bap.Std.Bitvector.t
          val of_int64 : ?width:int -> int64 -> Bap.Std.Bitvector.t
          val b0 : Bap.Std.Bitvector.t
          val b1 : Bap.Std.Bitvector.t
          val one : int -> Bap.Std.Bitvector.t
          val zero : int -> Bap.Std.Bitvector.t
          val ones : int -> Bap.Std.Bitvector.t
          val of_binary :
            ?width:int ->
            Bap.Std.Bitvector.endian -> string -> Bap.Std.Bitvector.t
          val to_int : Bap.Std.Bitvector.t -> int Core_kernel.Std.Or_error.t
          val to_int32 :
            Bap.Std.Bitvector.t -> int32 Core_kernel.Std.Or_error.t
          val to_int64 :
            Bap.Std.Bitvector.t -> int64 Core_kernel.Std.Or_error.t
          val to_int_exn : Bap.Std.Bitvector.t -> int
          val to_int32_exn : Bap.Std.Bitvector.t -> int32
          val to_int64_exn : Bap.Std.Bitvector.t -> int64
          val pp : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_hex : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_dec : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_oct : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_bin : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_hex_full : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_dec_full : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_oct_full : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_bin_full : Bap.Std.Bitvector.t Regular.Std.printer
          val pp_generic :
            ?case:[ `lower | `upper ] ->
            ?prefix:[ `auto | `base | `none | `this of string ] ->
            ?suffix:[ `full | `none | `size ] ->
            ?format:[ `bin | `dec | `hex | `oct ] ->
            Bap.Std.Bitvector.t Regular.Std.printer
          val string_of_value : ?hex:bool -> Bap.Std.Bitvector.t -> string
          val signed : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val unsigned : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val is_zero : Bap.Std.Bitvector.t -> bool
          val is_one : Bap.Std.Bitvector.t -> bool
          val bitwidth : Bap.Std.Bitvector.t -> int
          val extract :
            ?hi:int ->
            ?lo:int ->
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
          val extract_exn :
            ?hi:int -> ?lo:int -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val concat :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val ( @. ) :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val succ : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val pred : Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val nsucc : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
          val npred : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
          val ( ++ ) : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
          val ( -- ) : Bap.Std.Bitvector.t -> int -> Bap.Std.Bitvector.t
          val gcd :
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
          val lcm :
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
          val gcdext :
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.t ->
            (Bap.Std.Bitvector.t * Bap.Std.Bitvector.t * Bap.Std.Bitvector.t)
            Core_kernel.Std.Or_error.t
          val gcd_exn :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val lcm_exn :
            Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t -> Bap.Std.Bitvector.t
          val gcdext_exn :
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.t * Bap.Std.Bitvector.t * Bap.Std.Bitvector.t
          val enum_bytes :
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.endian -> Bap.Std.Bitvector.t Bap.Std.seq
          val enum_chars :
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.endian -> char Bap.Std.seq
          val enum_bits :
            Bap.Std.Bitvector.t ->
            Bap.Std.Bitvector.endian -> bool Bap.Std.seq
          val validate_positive :
            Bap.Std.Bitvector.t Core_kernel.Std.Validate.check
          val validate_non_negative :
            Bap.Std.Bitvector.t Core_kernel.Std.Validate.check
          val validate_negative :
            Bap.Std.Bitvector.t Core_kernel.Std.Validate.check
          val validate_non_positive :
            Bap.Std.Bitvector.t Core_kernel.Std.Validate.check
          val is_positive : Bap.Std.Bitvector.t -> bool
          val is_non_negative : Bap.Std.Bitvector.t -> bool
          val is_negative : Bap.Std.Bitvector.t -> bool
          val is_non_positive : Bap.Std.Bitvector.t -> bool
          module Int_err :
            sig
              val ( !$ ) :
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              val i1 :
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              val i4 :
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              val i8 :
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              val i16 :
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              val i32 :
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              val i64 :
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              val int :
                int ->
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              val of_word_size :
                Core_kernel.Std.Word_size.t ->
                Bap.Std.Bitvector.t ->
                Bap.Std.Bitvector.t Core_kernel.Std.Or_error.t
              type t = Hash_set.elt Core_kernel.Std.Or_error.t
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
              val ( >>= ) :
                'Core_kernel.Std.Or_error.t ->
                ('-> 'Core_kernel.Std.Or_error.t) ->
                'Core_kernel.Std.Or_error.t
              val ( >>| ) :
                'Core_kernel.Std.Or_error.t ->
                ('-> 'b) -> 'Core_kernel.Std.Or_error.t
            end
          module Int_exn :
            sig
              type t = Hash_set.elt
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
            end
          module Unsafe :
            sig
              type t = Int_exn.t
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
            end
          module Stable :
            sig
              module V1 :
                sig
                  type nonrec t = Bap.Std.Bitvector.t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              module V2 :
                sig
                  type nonrec t = Bap.Std.Bitvector.t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
            end
          module Trie :
            sig
              module Big :
                sig
                  module Bits :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = Unsafe.t
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module Bytes :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = Bits.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                end
              module Little :
                sig
                  module Bits :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = Unsafe.t
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module Bytes :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = Bits.key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                end
            end
        end
      type endian = Bap.Std.Bitvector.endian = LittleEndian | BigEndian
      val endian_of_sexp : Sexplib.Sexp.t -> endian
      val sexp_of_endian : endian -> Sexplib.Sexp.t
      val bin_endian : endian Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_endian : endian Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_endian__ :
        (int -> endian) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_endian :
        endian Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_endian : endian Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_endian : endian Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_endian :
        endian Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_endian : Core_kernel.Std.Bin_prot.Shape.t
      val compare_endian : endian -> endian -> int
      module Word :
        sig
          type t = word
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness = Bitvector.comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = word
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = Bitvector.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (word, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : word -> '-> 'a t
                  val of_alist :
                    (word * 'a) list ->
                    [ `Duplicate_key of word | `Ok of 'a t ]
                  val of_alist_or_error :
                    (word * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (word * 'a) list -> 'a t
                  val of_alist_multi : (word * 'a) list -> 'a list t
                  val of_alist_fold :
                    (word * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (word * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (word * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (word * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> word * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:word -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of word | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (word, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    word Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:word -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:word -> data:'-> 'a list t
                  val remove_multi : 'a list t -> word -> 'a list t
                  val change :
                    'a t -> word -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> word -> 'a option
                  val find_exn : 'a t -> word -> 'a
                  val remove : 'a t -> word -> 'a t
                  val mem : 'a t -> word -> bool
                  val iter_keys : 'a t -> f:(word -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:word -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:word ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:word -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:word ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(word -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:word -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:word -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:word -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:word -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> word list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (word * 'a) list
                  val validate :
                    name:(word -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:word ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (word, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (word * 'a) option
                  val min_elt_exn : 'a t -> word * 'a
                  val max_elt : 'a t -> (word * 'a) option
                  val max_elt_exn : 'a t -> word * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:word -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:word -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:word -> data:'-> bool) -> int
                  val split :
                    'a t -> word -> 'a t * (word * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:word Base__.Maybe_bound.t ->
                    upper_bound:word Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:word ->
                    max:word ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:word -> max:word -> (word * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> word -> (word * 'a) option
                  val nth : 'a t -> int -> (word * 'a) option
                  val nth_exn : 'a t -> int -> word * 'a
                  val rank : 'a t -> word -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:word ->
                    ?keys_less_or_equal_to:word ->
                    'a t -> (word * 'a) Base__.Sequence.t
                  val obs :
                    word Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    word Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> word end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (word, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : word -> '-> 'a t
              val of_alist :
                (word * 'a) list -> [ `Duplicate_key of word | `Ok of 'a t ]
              val of_alist_or_error :
                (word * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (word * 'a) list -> 'a t
              val of_alist_multi : (word * 'a) list -> 'a list t
              val of_alist_fold :
                (word * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (word * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (word * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (word * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> word * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:word -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of word | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (word, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                word Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:word -> data:'-> 'a t
              val add_multi : 'a list t -> key:word -> data:'-> 'a list t
              val remove_multi : 'a list t -> word -> 'a list t
              val change : 'a t -> word -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> word -> 'a option
              val find_exn : 'a t -> word -> 'a
              val remove : 'a t -> word -> 'a t
              val mem : 'a t -> word -> bool
              val iter_keys : 'a t -> f:(word -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:word -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:word ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:word -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:word ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(word -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:word -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:word -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:word -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:word -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> word list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (word * 'a) list
              val validate :
                name:(word -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:word ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (word, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (word * 'a) option
              val min_elt_exn : 'a t -> word * 'a
              val max_elt : 'a t -> (word * 'a) option
              val max_elt_exn : 'a t -> word * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:word -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:word -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:word -> data:'-> bool) -> int
              val split : 'a t -> word -> 'a t * (word * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:word Base__.Maybe_bound.t ->
                upper_bound:word Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:word ->
                max:word ->
                init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:word -> max:word -> (word * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> word -> (word * 'a) option
              val nth : 'a t -> int -> (word * 'a) option
              val nth_exn : 'a t -> int -> word * 'a
              val rank : 'a t -> word -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:word ->
                ?keys_less_or_equal_to:word ->
                'a t -> (word * 'a) Base__.Sequence.t
              val obs :
                word Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                word Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> word end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : word Bin_prot.Type_class.t
                           val bin_read_t : word Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> word)
                             Bin_prot.Read.reader
                           val bin_reader_t : word Bin_prot.Type_class.reader
                           val bin_size_t : word Bin_prot.Size.sizer
                           val bin_write_t : word Bin_prot.Write.writer
                           val bin_writer_t : word Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> word -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = word
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Bitvector.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (word, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(word -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> word -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(word -> bool) -> bool
                  val for_all : t -> f:(word -> bool) -> bool
                  val count : t -> f:(word -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(word -> 'sum) -> 'sum
                  val find : t -> f:(word -> bool) -> word option
                  val find_map : t -> f:(word -> 'a option) -> 'a option
                  val to_list : t -> word list
                  val to_array : t -> word array
                  val invariants : t -> bool
                  val mem : t -> word -> bool
                  val add : t -> word -> t
                  val remove : t -> word -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       word ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(word -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of word * word
                       | `Left of word
                       | `Right of word ] -> unit) ->
                    unit
                  val filter : t -> f:(word -> bool) -> t
                  val partition_tf : t -> f:(word -> bool) -> t * t
                  val elements : t -> word list
                  val min_elt : t -> word option
                  val min_elt_exn : t -> word
                  val max_elt : t -> word option
                  val max_elt_exn : t -> word
                  val choose : t -> word option
                  val choose_exn : t -> word
                  val split : t -> word -> t * word option * t
                  val group_by : t -> equiv:(word -> word -> bool) -> t list
                  val find_exn : t -> f:(word -> bool) -> word
                  val find_index : t -> int -> word option
                  val nth : t -> int -> word option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:word ->
                    ?less_or_equal_to:word -> t -> word Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:word ->
                    ?less_or_equal_to:word ->
                    t ->
                    t ->
                    (word, word)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(word -> 'data) ->
                    (word, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    word Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    word Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : word -> t
                  val union_list : t list -> t
                  val of_list : word list -> t
                  val of_array : word array -> t
                  val of_sorted_array : word array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : word array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> word) -> t
                  val stable_dedup_list : word list -> word list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> word) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> word option) -> t
                  val of_tree : t -> t
                  val of_hash_set : word Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (word, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (word, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    word Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> word end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (word, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(word -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> word -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(word -> bool) -> bool
              val for_all : t -> f:(word -> bool) -> bool
              val count : t -> f:(word -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(word -> 'sum) -> 'sum
              val find : t -> f:(word -> bool) -> word option
              val find_map : t -> f:(word -> 'a option) -> 'a option
              val to_list : t -> word list
              val to_array : t -> word array
              val invariants : t -> bool
              val mem : t -> word -> bool
              val add : t -> word -> t
              val remove : t -> word -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   word ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(word -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of word * word | `Left of word | `Right of word ] ->
                   unit) ->
                unit
              val filter : t -> f:(word -> bool) -> t
              val partition_tf : t -> f:(word -> bool) -> t * t
              val elements : t -> word list
              val min_elt : t -> word option
              val min_elt_exn : t -> word
              val max_elt : t -> word option
              val max_elt_exn : t -> word
              val choose : t -> word option
              val choose_exn : t -> word
              val split : t -> word -> t * word option * t
              val group_by : t -> equiv:(word -> word -> bool) -> t list
              val find_exn : t -> f:(word -> bool) -> word
              val find_index : t -> int -> word option
              val nth : t -> int -> word option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:word ->
                ?less_or_equal_to:word -> t -> word Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:word ->
                ?less_or_equal_to:word ->
                t ->
                t ->
                (word, word)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(word -> 'data) ->
                (word, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                word Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                word Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : word -> t
              val union_list : t list -> t
              val of_list : word list -> t
              val of_array : word array -> t
              val of_sorted_array : word array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : word array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> word) -> t
              val stable_dedup_list : word list -> word list
              val map : ('a, 'b) Base.Set.t -> f:('-> word) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> word option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : word Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (word, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (word, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                word Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> word end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : word Bin_prot.Type_class.t
                           val bin_read_t : word Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> word)
                             Bin_prot.Read.reader
                           val bin_reader_t : word Bin_prot.Type_class.reader
                           val bin_size_t : word Bin_prot.Size.sizer
                           val bin_write_t : word Bin_prot.Write.writer
                           val bin_writer_t : word Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> word -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Bitvector.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = word
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> word -> Core_kernel__.Import.bool
              val lookup : 'a t -> word -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> word -> 'a
              val enqueue :
                'a t -> word -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> word -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> word -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> word -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (word * 'a) Core_kernel__.Import.option
              val keys : 'a t -> word Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (word * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> word * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> word -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> word -> Core_kernel__.Import.unit
              val replace : 'a t -> word -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> word -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:word -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:word -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
          module Mono :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = word
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (word, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : word -> '-> 'a t
                      val of_alist :
                        (word * 'a) list ->
                        [ `Duplicate_key of word | `Ok of 'a t ]
                      val of_alist_or_error :
                        (word * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (word * 'a) list -> 'a t
                      val of_alist_multi : (word * 'a) list -> 'a list t
                      val of_alist_fold :
                        (word * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (word * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (word * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (word * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> word * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:word -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of word | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (word, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        word Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:word -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:word -> data:'-> 'a list t
                      val remove_multi : 'a list t -> word -> 'a list t
                      val change :
                        'a t -> word -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> word -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> word -> 'a option
                      val find_exn : 'a t -> word -> 'a
                      val remove : 'a t -> word -> 'a t
                      val mem : 'a t -> word -> bool
                      val iter_keys : 'a t -> f:(word -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:word -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:word ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:word -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:word ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(word -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:word -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:word -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:word -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:word -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> word list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (word * 'a) list
                      val validate :
                        name:(word -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:word ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (word, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (word * 'a) option
                      val min_elt_exn : 'a t -> word * 'a
                      val max_elt : 'a t -> (word * 'a) option
                      val max_elt_exn : 'a t -> word * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:word -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:word -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:word -> data:'-> bool) -> int
                      val split :
                        'a t -> word -> 'a t * (word * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:word Base__.Maybe_bound.t ->
                        upper_bound:word Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:word ->
                        max:word ->
                        init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:word -> max:word -> (word * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> word -> (word * 'a) option
                      val nth : 'a t -> int -> (word * 'a) option
                      val nth_exn : 'a t -> int -> word * 'a
                      val rank : 'a t -> word -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:word ->
                        ?keys_less_or_equal_to:word ->
                        'a t -> (word * 'a) Base__.Sequence.t
                      val obs :
                        word Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        word Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig val t_of_sexp : Sexplib.Sexp.t -> word end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (word, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : word -> '-> 'a t
                  val of_alist :
                    (word * 'a) list ->
                    [ `Duplicate_key of word | `Ok of 'a t ]
                  val of_alist_or_error :
                    (word * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (word * 'a) list -> 'a t
                  val of_alist_multi : (word * 'a) list -> 'a list t
                  val of_alist_fold :
                    (word * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (word * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (word * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (word * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> word * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:word -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of word | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (word, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    word Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:word -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:word -> data:'-> 'a list t
                  val remove_multi : 'a list t -> word -> 'a list t
                  val change :
                    'a t -> word -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> word -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> word -> 'a option
                  val find_exn : 'a t -> word -> 'a
                  val remove : 'a t -> word -> 'a t
                  val mem : 'a t -> word -> bool
                  val iter_keys : 'a t -> f:(word -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:word -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:word ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:word -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:word ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(word -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:word -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:word -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:word -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:word -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> word list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (word * 'a) list
                  val validate :
                    name:(word -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:word ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (word, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (word * 'a) option
                  val min_elt_exn : 'a t -> word * 'a
                  val max_elt : 'a t -> (word * 'a) option
                  val max_elt_exn : 'a t -> word * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:word -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:word -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:word -> data:'-> bool) -> int
                  val split :
                    'a t -> word -> 'a t * (word * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:word Base__.Maybe_bound.t ->
                    upper_bound:word Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:word ->
                    max:word ->
                    init:'-> f:(key:word -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:word -> max:word -> (word * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> word -> (word * 'a) option
                  val nth : 'a t -> int -> (word * 'a) option
                  val nth_exn : 'a t -> int -> word * 'a
                  val rank : 'a t -> word -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:word ->
                    ?keys_less_or_equal_to:word ->
                    'a t -> (word * 'a) Base__.Sequence.t
                  val obs :
                    word Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    word Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> word end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : word Bin_prot.Type_class.t
                               val bin_read_t : word Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> word)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 word Bin_prot.Type_class.reader
                               val bin_size_t : word Bin_prot.Size.sizer
                               val bin_write_t : word Bin_prot.Write.writer
                               val bin_writer_t :
                                 word Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 word -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = word
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (word, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(word -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> word -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(word -> bool) -> bool
                      val for_all : t -> f:(word -> bool) -> bool
                      val count : t -> f:(word -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(word -> 'sum) -> 'sum
                      val find : t -> f:(word -> bool) -> word option
                      val find_map : t -> f:(word -> 'a option) -> 'a option
                      val to_list : t -> word list
                      val to_array : t -> word array
                      val invariants : t -> bool
                      val mem : t -> word -> bool
                      val add : t -> word -> t
                      val remove : t -> word -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (word, word) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           word ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(word -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of word * word
                           | `Left of word
                           | `Right of word ] -> unit) ->
                        unit
                      val filter : t -> f:(word -> bool) -> t
                      val partition_tf : t -> f:(word -> bool) -> t * t
                      val elements : t -> word list
                      val min_elt : t -> word option
                      val min_elt_exn : t -> word
                      val max_elt : t -> word option
                      val max_elt_exn : t -> word
                      val choose : t -> word option
                      val choose_exn : t -> word
                      val split : t -> word -> t * word option * t
                      val group_by :
                        t -> equiv:(word -> word -> bool) -> t list
                      val find_exn : t -> f:(word -> bool) -> word
                      val find_index : t -> int -> word option
                      val nth : t -> int -> word option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:word ->
                        ?less_or_equal_to:word -> t -> word Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:word ->
                        ?less_or_equal_to:word ->
                        t ->
                        t ->
                        (word, word)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(word -> 'data) ->
                        (word, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        word Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        word Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : word -> t
                      val union_list : t list -> t
                      val of_list : word list -> t
                      val of_array : word array -> t
                      val of_sorted_array : word array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : word array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> word) -> t
                      val stable_dedup_list : word list -> word list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> word) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> word option) -> t
                      val of_tree : t -> t
                      val of_hash_set : word Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (word, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (word, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        word Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> word
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (word, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(word -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> word -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> word -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(word -> bool) -> bool
                  val for_all : t -> f:(word -> bool) -> bool
                  val count : t -> f:(word -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(word -> 'sum) -> 'sum
                  val find : t -> f:(word -> bool) -> word option
                  val find_map : t -> f:(word -> 'a option) -> 'a option
                  val to_list : t -> word list
                  val to_array : t -> word array
                  val invariants : t -> bool
                  val mem : t -> word -> bool
                  val add : t -> word -> t
                  val remove : t -> word -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (word, word) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       word ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(word -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of word * word
                       | `Left of word
                       | `Right of word ] -> unit) ->
                    unit
                  val filter : t -> f:(word -> bool) -> t
                  val partition_tf : t -> f:(word -> bool) -> t * t
                  val elements : t -> word list
                  val min_elt : t -> word option
                  val min_elt_exn : t -> word
                  val max_elt : t -> word option
                  val max_elt_exn : t -> word
                  val choose : t -> word option
                  val choose_exn : t -> word
                  val split : t -> word -> t * word option * t
                  val group_by : t -> equiv:(word -> word -> bool) -> t list
                  val find_exn : t -> f:(word -> bool) -> word
                  val find_index : t -> int -> word option
                  val nth : t -> int -> word option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:word ->
                    ?less_or_equal_to:word -> t -> word Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:word ->
                    ?less_or_equal_to:word ->
                    t ->
                    t ->
                    (word, word)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(word -> 'data) ->
                    (word, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    word Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    word Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : word -> t
                  val union_list : t list -> t
                  val of_list : word list -> t
                  val of_array : word array -> t
                  val of_sorted_array : word array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : word array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> word) -> t
                  val stable_dedup_list : word list -> word list
                  val map : ('a, 'b) Base.Set.t -> f:('-> word) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> word option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : word Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (word, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (word, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    word Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> word end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : word Bin_prot.Type_class.t
                               val bin_read_t : word Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> word)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 word Bin_prot.Type_class.reader
                               val bin_size_t : word Bin_prot.Size.sizer
                               val bin_write_t : word Bin_prot.Write.writer
                               val bin_writer_t :
                                 word Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 word -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
            end
          type endian = Bap.Std.Bitvector.endian = LittleEndian | BigEndian
          val bin_endian : endian Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_endian : endian Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_endian__ :
            (int -> endian) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_endian :
            endian Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_endian : endian Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_endian : endian Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_endian :
            endian Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_endian : Core_kernel.Std.Bin_prot.Shape.t
          val compare_endian : endian -> endian -> int
          val endian_of_sexp : Sexplib.Sexp.t -> endian
          val sexp_of_endian : endian -> Sexplib.Sexp.t
          val of_string : Trie.String.Suffix.key -> t
          val of_bool : bool -> t
          val of_int : width:int -> int -> t
          val of_int32 : ?width:int -> int32 -> t
          val of_int64 : ?width:int -> int64 -> t
          val b0 : t
          val b1 : t
          val one : int -> t
          val zero : int -> t
          val ones : int -> t
          val of_binary : ?width:int -> endian -> Trie.String.Suffix.key -> t
          val to_int : t -> int Core_kernel.Std.Or_error.t
          val to_int32 : t -> int32 Core_kernel.Std.Or_error.t
          val to_int64 : t -> int64 Core_kernel.Std.Or_error.t
          val to_int_exn : t -> int
          val to_int32_exn : t -> int32
          val to_int64_exn : t -> int64
          val pp : t Regular.Std.printer
          val pp_hex : t Regular.Std.printer
          val pp_dec : t Regular.Std.printer
          val pp_oct : t Regular.Std.printer
          val pp_bin : t Regular.Std.printer
          val pp_hex_full : t Regular.Std.printer
          val pp_dec_full : t Regular.Std.printer
          val pp_oct_full : t Regular.Std.printer
          val pp_bin_full : t Regular.Std.printer
          val pp_generic :
            ?case:[ `lower | `upper ] ->
            ?prefix:[ `auto | `base | `none | `this of Trie.String.Suffix.key ] ->
            ?suffix:[ `full | `none | `size ] ->
            ?format:[ `bin | `dec | `hex | `oct ] -> t Regular.Std.printer
          val string_of_value : ?hex:bool -> t -> Trie.String.Suffix.key
          val signed : t -> t
          val unsigned : t -> t
          val is_zero : t -> bool
          val is_one : t -> bool
          val bitwidth : t -> int
          val extract :
            ?hi:int -> ?lo:int -> t -> t Core_kernel.Std.Or_error.t
          val extract_exn : ?hi:int -> ?lo:int -> t -> t
          val concat : t -> t -> t
          val ( @. ) : t -> t -> t
          val succ : t -> t
          val pred : t -> t
          val nsucc : t -> int -> t
          val npred : t -> int -> t
          val ( ++ ) : t -> int -> t
          val ( -- ) : t -> int -> t
          val gcd : t -> t -> t Core_kernel.Std.Or_error.t
          val lcm : t -> t -> t Core_kernel.Std.Or_error.t
          val gcdext : t -> t -> (t * t * t) Core_kernel.Std.Or_error.t
          val gcd_exn : t -> t -> t
          val lcm_exn : t -> t -> t
          val gcdext_exn : t -> t -> t * t * t
          val enum_bytes : t -> endian -> t seq
          val enum_chars : t -> endian -> char seq
          val enum_bits : t -> endian -> bool seq
          val validate_positive : t Core_kernel.Std.Validate.check
          val validate_non_negative : t Core_kernel.Std.Validate.check
          val validate_negative : t Core_kernel.Std.Validate.check
          val validate_non_positive : t Core_kernel.Std.Validate.check
          val is_positive : t -> bool
          val is_non_negative : t -> bool
          val is_negative : t -> bool
          val is_non_positive : t -> bool
          module Int_err :
            sig
              val ( !$ ) : t -> t Core_kernel.Std.Or_error.t
              val i1 : t -> t Core_kernel.Std.Or_error.t
              val i4 : t -> t Core_kernel.Std.Or_error.t
              val i8 : t -> t Core_kernel.Std.Or_error.t
              val i16 : t -> t Core_kernel.Std.Or_error.t
              val i32 : t -> t Core_kernel.Std.Or_error.t
              val i64 : t -> t Core_kernel.Std.Or_error.t
              val int : int -> t -> t Core_kernel.Std.Or_error.t
              val of_word_size :
                Core_kernel.Std.Word_size.t ->
                t -> t Core_kernel.Std.Or_error.t
              type t = word Core_kernel.Std.Or_error.t
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
              val ( >>= ) :
                'Core_kernel.Std.Or_error.t ->
                ('-> 'Core_kernel.Std.Or_error.t) ->
                'Core_kernel.Std.Or_error.t
              val ( >>| ) :
                'Core_kernel.Std.Or_error.t ->
                ('-> 'b) -> 'Core_kernel.Std.Or_error.t
            end
          module Int_exn :
            sig
              type t = word
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
            end
          module Unsafe :
            sig
              type t = word
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
            end
          module Stable :
            sig
              module V1 :
                sig
                  type nonrec t = t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              module V2 :
                sig
                  type nonrec t = t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
            end
          module Trie :
            sig
              module Big :
                sig
                  module Bits :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = word
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module Bytes :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = word
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                end
              module Little :
                sig
                  module Bits :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = word
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module Bytes :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = word
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                end
            end
        end
      module Addr :
        sig
          type t = addr
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness = Word.comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = addr
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = Word.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (addr, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : addr -> '-> 'a t
                  val of_alist :
                    (addr * 'a) list ->
                    [ `Duplicate_key of addr | `Ok of 'a t ]
                  val of_alist_or_error :
                    (addr * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (addr * 'a) list -> 'a t
                  val of_alist_multi : (addr * 'a) list -> 'a list t
                  val of_alist_fold :
                    (addr * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (addr * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (addr * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> addr * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:addr -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of addr | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (addr, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    addr Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:addr -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:addr -> data:'-> 'a list t
                  val remove_multi : 'a list t -> addr -> 'a list t
                  val change :
                    'a t -> addr -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> addr -> 'a option
                  val find_exn : 'a t -> addr -> 'a
                  val remove : 'a t -> addr -> 'a t
                  val mem : 'a t -> addr -> bool
                  val iter_keys : 'a t -> f:(addr -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:addr -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:addr ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:addr -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:addr ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:addr -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:addr -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:addr -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:addr -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> addr list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (addr * 'a) list
                  val validate :
                    name:(addr -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:addr ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (addr, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (addr * 'a) option
                  val min_elt_exn : 'a t -> addr * 'a
                  val max_elt : 'a t -> (addr * 'a) option
                  val max_elt_exn : 'a t -> addr * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:addr -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:addr -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:addr -> data:'-> bool) -> int
                  val split :
                    'a t -> addr -> 'a t * (addr * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:addr Base__.Maybe_bound.t ->
                    upper_bound:addr Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:addr ->
                    max:addr ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:addr -> max:addr -> (addr * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> addr -> (addr * 'a) option
                  val nth : 'a t -> int -> (addr * 'a) option
                  val nth_exn : 'a t -> int -> addr * 'a
                  val rank : 'a t -> addr -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:addr ->
                    ?keys_less_or_equal_to:addr ->
                    'a t -> (addr * 'a) Base__.Sequence.t
                  val obs :
                    addr Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    addr Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> addr end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (addr, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : addr -> '-> 'a t
              val of_alist :
                (addr * 'a) list -> [ `Duplicate_key of addr | `Ok of 'a t ]
              val of_alist_or_error :
                (addr * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (addr * 'a) list -> 'a t
              val of_alist_multi : (addr * 'a) list -> 'a list t
              val of_alist_fold :
                (addr * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (addr * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (addr * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> addr * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:addr -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of addr | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (addr, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                addr Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:addr -> data:'-> 'a t
              val add_multi : 'a list t -> key:addr -> data:'-> 'a list t
              val remove_multi : 'a list t -> addr -> 'a list t
              val change : 'a t -> addr -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> addr -> 'a option
              val find_exn : 'a t -> addr -> 'a
              val remove : 'a t -> addr -> 'a t
              val mem : 'a t -> addr -> bool
              val iter_keys : 'a t -> f:(addr -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:addr -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:addr ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:addr -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:addr ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:addr -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:addr -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:addr -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:addr -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> addr list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (addr * 'a) list
              val validate :
                name:(addr -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:addr ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (addr, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (addr * 'a) option
              val min_elt_exn : 'a t -> addr * 'a
              val max_elt : 'a t -> (addr * 'a) option
              val max_elt_exn : 'a t -> addr * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:addr -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:addr -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:addr -> data:'-> bool) -> int
              val split : 'a t -> addr -> 'a t * (addr * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:addr Base__.Maybe_bound.t ->
                upper_bound:addr Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:addr ->
                max:addr ->
                init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:addr -> max:addr -> (addr * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> addr -> (addr * 'a) option
              val nth : 'a t -> int -> (addr * 'a) option
              val nth_exn : 'a t -> int -> addr * 'a
              val rank : 'a t -> addr -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:addr ->
                ?keys_less_or_equal_to:addr ->
                'a t -> (addr * 'a) Base__.Sequence.t
              val obs :
                addr Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                addr Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> addr end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : addr Bin_prot.Type_class.t
                           val bin_read_t : addr Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> addr)
                             Bin_prot.Read.reader
                           val bin_reader_t : addr Bin_prot.Type_class.reader
                           val bin_size_t : addr Bin_prot.Size.sizer
                           val bin_write_t : addr Bin_prot.Write.writer
                           val bin_writer_t : addr Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> addr -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = addr
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Word.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (addr, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(addr -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(addr -> bool) -> bool
                  val for_all : t -> f:(addr -> bool) -> bool
                  val count : t -> f:(addr -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(addr -> 'sum) -> 'sum
                  val find : t -> f:(addr -> bool) -> addr option
                  val find_map : t -> f:(addr -> 'a option) -> 'a option
                  val to_list : t -> addr list
                  val to_array : t -> addr array
                  val invariants : t -> bool
                  val mem : t -> addr -> bool
                  val add : t -> addr -> t
                  val remove : t -> addr -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       addr ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(addr -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of addr * addr
                       | `Left of addr
                       | `Right of addr ] -> unit) ->
                    unit
                  val filter : t -> f:(addr -> bool) -> t
                  val partition_tf : t -> f:(addr -> bool) -> t * t
                  val elements : t -> addr list
                  val min_elt : t -> addr option
                  val min_elt_exn : t -> addr
                  val max_elt : t -> addr option
                  val max_elt_exn : t -> addr
                  val choose : t -> addr option
                  val choose_exn : t -> addr
                  val split : t -> addr -> t * addr option * t
                  val group_by : t -> equiv:(addr -> addr -> bool) -> t list
                  val find_exn : t -> f:(addr -> bool) -> addr
                  val find_index : t -> int -> addr option
                  val nth : t -> int -> addr option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:addr ->
                    ?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:addr ->
                    ?less_or_equal_to:addr ->
                    t ->
                    t ->
                    (addr, addr)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(addr -> 'data) ->
                    (addr, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    addr Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    addr Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : addr -> t
                  val union_list : t list -> t
                  val of_list : addr list -> t
                  val of_array : addr array -> t
                  val of_sorted_array : addr array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : addr array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> addr) -> t
                  val stable_dedup_list : addr list -> addr list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> addr) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> addr option) -> t
                  val of_tree : t -> t
                  val of_hash_set : addr Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (addr, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (addr, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    addr Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> addr end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (addr, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(addr -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(addr -> bool) -> bool
              val for_all : t -> f:(addr -> bool) -> bool
              val count : t -> f:(addr -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(addr -> 'sum) -> 'sum
              val find : t -> f:(addr -> bool) -> addr option
              val find_map : t -> f:(addr -> 'a option) -> 'a option
              val to_list : t -> addr list
              val to_array : t -> addr array
              val invariants : t -> bool
              val mem : t -> addr -> bool
              val add : t -> addr -> t
              val remove : t -> addr -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   addr ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(addr -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of addr * addr | `Left of addr | `Right of addr ] ->
                   unit) ->
                unit
              val filter : t -> f:(addr -> bool) -> t
              val partition_tf : t -> f:(addr -> bool) -> t * t
              val elements : t -> addr list
              val min_elt : t -> addr option
              val min_elt_exn : t -> addr
              val max_elt : t -> addr option
              val max_elt_exn : t -> addr
              val choose : t -> addr option
              val choose_exn : t -> addr
              val split : t -> addr -> t * addr option * t
              val group_by : t -> equiv:(addr -> addr -> bool) -> t list
              val find_exn : t -> f:(addr -> bool) -> addr
              val find_index : t -> int -> addr option
              val nth : t -> int -> addr option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:addr ->
                ?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:addr ->
                ?less_or_equal_to:addr ->
                t ->
                t ->
                (addr, addr)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(addr -> 'data) ->
                (addr, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                addr Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                addr Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : addr -> t
              val union_list : t list -> t
              val of_list : addr list -> t
              val of_array : addr array -> t
              val of_sorted_array : addr array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : addr array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> addr) -> t
              val stable_dedup_list : addr list -> addr list
              val map : ('a, 'b) Base.Set.t -> f:('-> addr) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> addr option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : addr Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (addr, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (addr, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                addr Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> addr end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : addr Bin_prot.Type_class.t
                           val bin_read_t : addr Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> addr)
                             Bin_prot.Read.reader
                           val bin_reader_t : addr Bin_prot.Type_class.reader
                           val bin_size_t : addr Bin_prot.Size.sizer
                           val bin_write_t : addr Bin_prot.Write.writer
                           val bin_writer_t : addr Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> addr -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Word.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = addr
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> addr -> Core_kernel__.Import.bool
              val lookup : 'a t -> addr -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> addr -> 'a
              val enqueue :
                'a t -> addr -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> addr -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> addr -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> addr -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (addr * 'a) Core_kernel__.Import.option
              val keys : 'a t -> addr Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (addr * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> addr * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> addr -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> addr -> Core_kernel__.Import.unit
              val replace : 'a t -> addr -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> addr -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:addr -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:addr -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val abs : t -> t
          val neg : t -> t
          val add : t -> t -> t
          val sub : t -> t -> t
          val mul : t -> t -> t
          val div : t -> t -> t
          val modulo : t -> t -> t
          val lnot : t -> t
          val logand : t -> t -> t
          val logor : t -> t -> t
          val logxor : t -> t -> t
          val lshift : t -> t -> t
          val rshift : t -> t -> t
          val arshift : t -> t -> t
          val ( ~- ) : t -> t
          val ( + ) : t -> t -> t
          val ( - ) : t -> t -> t
          val ( * ) : t -> t -> t
          val ( / ) : t -> t -> t
          val ( mod ) : t -> t -> t
          val ( land ) : t -> t -> t
          val ( lor ) : t -> t -> t
          val ( lxor ) : t -> t -> t
          val ( lsl ) : t -> t -> t
          val ( lsr ) : t -> t -> t
          val ( asr ) : t -> t -> t
          module Mono :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = addr
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (addr, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : addr -> '-> 'a t
                      val of_alist :
                        (addr * 'a) list ->
                        [ `Duplicate_key of addr | `Ok of 'a t ]
                      val of_alist_or_error :
                        (addr * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (addr * 'a) list -> 'a t
                      val of_alist_multi : (addr * 'a) list -> 'a list t
                      val of_alist_fold :
                        (addr * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (addr * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (addr * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (addr * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> addr * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:addr -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of addr | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (addr, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        addr Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:addr -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:addr -> data:'-> 'a list t
                      val remove_multi : 'a list t -> addr -> 'a list t
                      val change :
                        'a t -> addr -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> addr -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> addr -> 'a option
                      val find_exn : 'a t -> addr -> 'a
                      val remove : 'a t -> addr -> 'a t
                      val mem : 'a t -> addr -> bool
                      val iter_keys : 'a t -> f:(addr -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:addr -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:addr ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:addr -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:addr ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:addr -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:addr -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:addr -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:addr -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> addr list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (addr * 'a) list
                      val validate :
                        name:(addr -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:addr ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (addr, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (addr * 'a) option
                      val min_elt_exn : 'a t -> addr * 'a
                      val max_elt : 'a t -> (addr * 'a) option
                      val max_elt_exn : 'a t -> addr * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:addr -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:addr -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:addr -> data:'-> bool) -> int
                      val split :
                        'a t -> addr -> 'a t * (addr * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:addr Base__.Maybe_bound.t ->
                        upper_bound:addr Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:addr ->
                        max:addr ->
                        init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:addr -> max:addr -> (addr * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> addr -> (addr * 'a) option
                      val nth : 'a t -> int -> (addr * 'a) option
                      val nth_exn : 'a t -> int -> addr * 'a
                      val rank : 'a t -> addr -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:addr ->
                        ?keys_less_or_equal_to:addr ->
                        'a t -> (addr * 'a) Base__.Sequence.t
                      val obs :
                        addr Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        addr Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig val t_of_sexp : Sexplib.Sexp.t -> addr end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (addr, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : addr -> '-> 'a t
                  val of_alist :
                    (addr * 'a) list ->
                    [ `Duplicate_key of addr | `Ok of 'a t ]
                  val of_alist_or_error :
                    (addr * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (addr * 'a) list -> 'a t
                  val of_alist_multi : (addr * 'a) list -> 'a list t
                  val of_alist_fold :
                    (addr * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (addr * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (addr * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (addr * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> addr * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:addr -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of addr | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (addr, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    addr Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:addr -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:addr -> data:'-> 'a list t
                  val remove_multi : 'a list t -> addr -> 'a list t
                  val change :
                    'a t -> addr -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> addr -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> addr -> 'a option
                  val find_exn : 'a t -> addr -> 'a
                  val remove : 'a t -> addr -> 'a t
                  val mem : 'a t -> addr -> bool
                  val iter_keys : 'a t -> f:(addr -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:addr -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:addr ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:addr -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:addr ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(addr -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:addr -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:addr -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:addr -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:addr -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> addr list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (addr * 'a) list
                  val validate :
                    name:(addr -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:addr ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (addr, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (addr * 'a) option
                  val min_elt_exn : 'a t -> addr * 'a
                  val max_elt : 'a t -> (addr * 'a) option
                  val max_elt_exn : 'a t -> addr * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:addr -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:addr -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:addr -> data:'-> bool) -> int
                  val split :
                    'a t -> addr -> 'a t * (addr * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:addr Base__.Maybe_bound.t ->
                    upper_bound:addr Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:addr ->
                    max:addr ->
                    init:'-> f:(key:addr -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:addr -> max:addr -> (addr * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> addr -> (addr * 'a) option
                  val nth : 'a t -> int -> (addr * 'a) option
                  val nth_exn : 'a t -> int -> addr * 'a
                  val rank : 'a t -> addr -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:addr ->
                    ?keys_less_or_equal_to:addr ->
                    'a t -> (addr * 'a) Base__.Sequence.t
                  val obs :
                    addr Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    addr Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> addr end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : addr Bin_prot.Type_class.t
                               val bin_read_t : addr Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> addr)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 addr Bin_prot.Type_class.reader
                               val bin_size_t : addr Bin_prot.Size.sizer
                               val bin_write_t : addr Bin_prot.Write.writer
                               val bin_writer_t :
                                 addr Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 addr -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = addr
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (addr, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(addr -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(addr -> bool) -> bool
                      val for_all : t -> f:(addr -> bool) -> bool
                      val count : t -> f:(addr -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(addr -> 'sum) -> 'sum
                      val find : t -> f:(addr -> bool) -> addr option
                      val find_map : t -> f:(addr -> 'a option) -> 'a option
                      val to_list : t -> addr list
                      val to_array : t -> addr array
                      val invariants : t -> bool
                      val mem : t -> addr -> bool
                      val add : t -> addr -> t
                      val remove : t -> addr -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (addr, addr) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           addr ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(addr -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of addr * addr
                           | `Left of addr
                           | `Right of addr ] -> unit) ->
                        unit
                      val filter : t -> f:(addr -> bool) -> t
                      val partition_tf : t -> f:(addr -> bool) -> t * t
                      val elements : t -> addr list
                      val min_elt : t -> addr option
                      val min_elt_exn : t -> addr
                      val max_elt : t -> addr option
                      val max_elt_exn : t -> addr
                      val choose : t -> addr option
                      val choose_exn : t -> addr
                      val split : t -> addr -> t * addr option * t
                      val group_by :
                        t -> equiv:(addr -> addr -> bool) -> t list
                      val find_exn : t -> f:(addr -> bool) -> addr
                      val find_index : t -> int -> addr option
                      val nth : t -> int -> addr option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:addr ->
                        ?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:addr ->
                        ?less_or_equal_to:addr ->
                        t ->
                        t ->
                        (addr, addr)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(addr -> 'data) ->
                        (addr, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        addr Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        addr Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : addr -> t
                      val union_list : t list -> t
                      val of_list : addr list -> t
                      val of_array : addr array -> t
                      val of_sorted_array : addr array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : addr array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> addr) -> t
                      val stable_dedup_list : addr list -> addr list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> addr) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> addr option) -> t
                      val of_tree : t -> t
                      val of_hash_set : addr Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (addr, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (addr, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        addr Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> addr
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (addr, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(addr -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> addr -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> addr -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(addr -> bool) -> bool
                  val for_all : t -> f:(addr -> bool) -> bool
                  val count : t -> f:(addr -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(addr -> 'sum) -> 'sum
                  val find : t -> f:(addr -> bool) -> addr option
                  val find_map : t -> f:(addr -> 'a option) -> 'a option
                  val to_list : t -> addr list
                  val to_array : t -> addr array
                  val invariants : t -> bool
                  val mem : t -> addr -> bool
                  val add : t -> addr -> t
                  val remove : t -> addr -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (addr, addr) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       addr ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(addr -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of addr * addr
                       | `Left of addr
                       | `Right of addr ] -> unit) ->
                    unit
                  val filter : t -> f:(addr -> bool) -> t
                  val partition_tf : t -> f:(addr -> bool) -> t * t
                  val elements : t -> addr list
                  val min_elt : t -> addr option
                  val min_elt_exn : t -> addr
                  val max_elt : t -> addr option
                  val max_elt_exn : t -> addr
                  val choose : t -> addr option
                  val choose_exn : t -> addr
                  val split : t -> addr -> t * addr option * t
                  val group_by : t -> equiv:(addr -> addr -> bool) -> t list
                  val find_exn : t -> f:(addr -> bool) -> addr
                  val find_index : t -> int -> addr option
                  val nth : t -> int -> addr option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:addr ->
                    ?less_or_equal_to:addr -> t -> addr Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:addr ->
                    ?less_or_equal_to:addr ->
                    t ->
                    t ->
                    (addr, addr)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(addr -> 'data) ->
                    (addr, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    addr Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    addr Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : addr -> t
                  val union_list : t list -> t
                  val of_list : addr list -> t
                  val of_array : addr array -> t
                  val of_sorted_array : addr array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : addr array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> addr) -> t
                  val stable_dedup_list : addr list -> addr list
                  val map : ('a, 'b) Base.Set.t -> f:('-> addr) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> addr option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : addr Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (addr, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (addr, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    addr Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> addr end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : addr Bin_prot.Type_class.t
                               val bin_read_t : addr Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> addr)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 addr Bin_prot.Type_class.reader
                               val bin_size_t : addr Bin_prot.Size.sizer
                               val bin_write_t : addr Bin_prot.Write.writer
                               val bin_writer_t :
                                 addr Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 addr -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
            end
          type endian = Word.endian = LittleEndian | BigEndian
          val bin_endian : endian Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_endian : endian Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_endian__ :
            (int -> endian) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_endian :
            endian Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_endian : endian Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_endian : endian Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_endian :
            endian Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_endian : Core_kernel.Std.Bin_prot.Shape.t
          val compare_endian : endian -> endian -> int
          val endian_of_sexp : Sexplib.Sexp.t -> endian
          val sexp_of_endian : endian -> Sexplib.Sexp.t
          val of_string : Trie.String.Suffix.key -> t
          val of_bool : bool -> t
          val of_int : width:int -> int -> t
          val of_int32 : ?width:int -> int32 -> t
          val of_int64 : ?width:int -> int64 -> t
          val b0 : t
          val b1 : t
          val one : int -> t
          val zero : int -> t
          val ones : int -> t
          val of_binary : ?width:int -> endian -> Trie.String.Suffix.key -> t
          val to_int : t -> int Core_kernel.Std.Or_error.t
          val to_int32 : t -> int32 Core_kernel.Std.Or_error.t
          val to_int64 : t -> int64 Core_kernel.Std.Or_error.t
          val to_int_exn : t -> int
          val to_int32_exn : t -> int32
          val to_int64_exn : t -> int64
          val pp : t Regular.Std.printer
          val pp_hex : t Regular.Std.printer
          val pp_dec : t Regular.Std.printer
          val pp_oct : t Regular.Std.printer
          val pp_bin : t Regular.Std.printer
          val pp_hex_full : t Regular.Std.printer
          val pp_dec_full : t Regular.Std.printer
          val pp_oct_full : t Regular.Std.printer
          val pp_bin_full : t Regular.Std.printer
          val pp_generic :
            ?case:[ `lower | `upper ] ->
            ?prefix:[ `auto | `base | `none | `this of Trie.String.Suffix.key ] ->
            ?suffix:[ `full | `none | `size ] ->
            ?format:[ `bin | `dec | `hex | `oct ] -> t Regular.Std.printer
          val string_of_value : ?hex:bool -> t -> Trie.String.Suffix.key
          val signed : t -> t
          val unsigned : t -> t
          val is_zero : t -> bool
          val is_one : t -> bool
          val bitwidth : t -> int
          val extract :
            ?hi:int -> ?lo:int -> t -> t Core_kernel.Std.Or_error.t
          val extract_exn : ?hi:int -> ?lo:int -> t -> t
          val concat : t -> t -> t
          val ( @. ) : t -> t -> t
          val succ : t -> t
          val pred : t -> t
          val nsucc : t -> int -> t
          val npred : t -> int -> t
          val ( ++ ) : t -> int -> t
          val ( -- ) : t -> int -> t
          val gcd : t -> t -> t Core_kernel.Std.Or_error.t
          val lcm : t -> t -> t Core_kernel.Std.Or_error.t
          val gcdext : t -> t -> (t * t * t) Core_kernel.Std.Or_error.t
          val gcd_exn : t -> t -> t
          val lcm_exn : t -> t -> t
          val gcdext_exn : t -> t -> t * t * t
          val enum_bytes : t -> endian -> t seq
          val enum_chars : t -> endian -> char seq
          val enum_bits : t -> endian -> bool seq
          val validate_positive : t Core_kernel.Std.Validate.check
          val validate_non_negative : t Core_kernel.Std.Validate.check
          val validate_negative : t Core_kernel.Std.Validate.check
          val validate_non_positive : t Core_kernel.Std.Validate.check
          val is_positive : t -> bool
          val is_non_negative : t -> bool
          val is_negative : t -> bool
          val is_non_positive : t -> bool
          module Int_err :
            sig
              val ( !$ ) : t -> t Core_kernel.Std.Or_error.t
              val i1 : t -> t Core_kernel.Std.Or_error.t
              val i4 : t -> t Core_kernel.Std.Or_error.t
              val i8 : t -> t Core_kernel.Std.Or_error.t
              val i16 : t -> t Core_kernel.Std.Or_error.t
              val i32 : t -> t Core_kernel.Std.Or_error.t
              val i64 : t -> t Core_kernel.Std.Or_error.t
              val int : int -> t -> t Core_kernel.Std.Or_error.t
              val of_word_size :
                Core_kernel.Std.Word_size.t ->
                t -> t Core_kernel.Std.Or_error.t
              type t = addr Core_kernel.Std.Or_error.t
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
              val ( >>= ) :
                'Core_kernel.Std.Or_error.t ->
                ('-> 'Core_kernel.Std.Or_error.t) ->
                'Core_kernel.Std.Or_error.t
              val ( >>| ) :
                'Core_kernel.Std.Or_error.t ->
                ('-> 'b) -> 'Core_kernel.Std.Or_error.t
            end
          module Int_exn :
            sig
              type t = addr
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
            end
          module Unsafe :
            sig
              type t = addr
              val zero : t
              val one : t
              val succ : t -> t
              val pred : t -> t
              val abs : t -> t
              val neg : t -> t
              val add : t -> t -> t
              val sub : t -> t -> t
              val mul : t -> t -> t
              val div : t -> t -> t
              val modulo : t -> t -> t
              val lnot : t -> t
              val logand : t -> t -> t
              val logor : t -> t -> t
              val logxor : t -> t -> t
              val lshift : t -> t -> t
              val rshift : t -> t -> t
              val arshift : t -> t -> t
              val ( ~- ) : t -> t
              val ( + ) : t -> t -> t
              val ( - ) : t -> t -> t
              val ( * ) : t -> t -> t
              val ( / ) : t -> t -> t
              val ( mod ) : t -> t -> t
              val ( land ) : t -> t -> t
              val ( lor ) : t -> t -> t
              val ( lxor ) : t -> t -> t
              val ( lsl ) : t -> t -> t
              val ( lsr ) : t -> t -> t
              val ( asr ) : t -> t -> t
            end
          module Stable :
            sig
              module V1 :
                sig
                  type nonrec t = t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
              module V2 :
                sig
                  type nonrec t = t
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
                  val compare : t -> t -> int
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                end
            end
          module Trie :
            sig
              module Big :
                sig
                  module Bits :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = addr
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module Bytes :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = addr
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                end
              module Little :
                sig
                  module Bits :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = addr
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  module Bytes :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = addr
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                end
            end
          val memref :
            ?disp:int ->
            ?index:int -> ?scale:Bap.Std.size -> Bap.Std.addr -> Bap.Std.addr
        end
      module Bil :
        sig
          module Types :
            sig
              type var
              type cast = UNSIGNED | SIGNED | HIGH | LOW
              val bin_cast : cast Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_cast : cast Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_cast__ :
                (int -> cast) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_cast :
                cast Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_cast : cast Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_cast : cast Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_cast :
                cast Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_cast : Core_kernel.Std.Bin_prot.Shape.t
              val compare_cast : cast -> cast -> int
              val cast_of_sexp : Sexplib.Sexp.t -> cast
              val sexp_of_cast : cast -> Sexplib.Sexp.t
              type binop =
                  PLUS
                | MINUS
                | TIMES
                | DIVIDE
                | SDIVIDE
                | MOD
                | SMOD
                | LSHIFT
                | RSHIFT
                | ARSHIFT
                | AND
                | OR
                | XOR
                | EQ
                | NEQ
                | LT
                | LE
                | SLT
                | SLE
              val bin_binop : binop Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_binop : binop Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_binop__ :
                (int -> binop) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_binop :
                binop Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_binop : binop Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_binop :
                binop Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_binop :
                binop Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_binop : Core_kernel.Std.Bin_prot.Shape.t
              val compare_binop : binop -> binop -> int
              val binop_of_sexp : Sexplib.Sexp.t -> binop
              val sexp_of_binop : binop -> Sexplib.Sexp.t
              type unop = NEG | NOT
              val bin_unop : unop Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_unop : unop Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_unop__ :
                (int -> unop) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_unop :
                unop Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_unop : unop Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_unop : unop Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_unop :
                unop Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_unop : Core_kernel.Std.Bin_prot.Shape.t
              val compare_unop : unop -> unop -> int
              val unop_of_sexp : Sexplib.Sexp.t -> unop
              val sexp_of_unop : unop -> Sexplib.Sexp.t
              type exp =
                  Load of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
                    Bap.Std.endian * Bap.Std.size
                | Store of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
                    Bap.Std.Bil.Types.exp * Bap.Std.endian * Bap.Std.size
                | BinOp of Bap.Std.Bil.Types.binop * Bap.Std.Bil.Types.exp *
                    Bap.Std.Bil.Types.exp
                | UnOp of Bap.Std.Bil.Types.unop * Bap.Std.Bil.Types.exp
                | Var of Bap.Std.Bil.Types.var
                | Int of Bap.Std.word
                | Cast of Bap.Std.Bil.Types.cast * int *
                    Bap.Std.Bil.Types.exp
                | Let of Bap.Std.Bil.Types.var * Bap.Std.Bil.Types.exp *
                    Bap.Std.Bil.Types.exp
                | Unknown of string * Bap.Std.Bil.Types.typ
                | Ite of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp *
                    Bap.Std.Bil.Types.exp
                | Extract of int * int * Bap.Std.Bil.Types.exp
                | Concat of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.exp
              and typ = Imm of int | Mem of Bap.Std.addr_size * Bap.Std.size
              val bin_exp : exp Core_kernel.Std.Bin_prot.Type_class.t
              val bin_typ : typ Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_exp : exp Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_exp__ :
                (int -> exp) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_exp :
                exp Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_read_typ : typ Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_typ__ :
                (int -> typ) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_typ :
                typ Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_exp : exp Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_exp : exp Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_exp :
                exp Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_size_typ : typ Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_typ : typ Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_typ :
                typ Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_exp : Core_kernel.Std.Bin_prot.Shape.t
              val bin_shape_typ : Core_kernel.Std.Bin_prot.Shape.t
              val compare_exp : exp -> exp -> int
              val compare_typ : typ -> typ -> int
              val exp_of_sexp : Sexplib.Sexp.t -> exp
              val typ_of_sexp : Sexplib.Sexp.t -> typ
              val sexp_of_exp : exp -> Sexplib.Sexp.t
              val sexp_of_typ : typ -> Sexplib.Sexp.t
              type stmt =
                  Move of Bap.Std.Bil.Types.var * Bap.Std.Bil.Types.exp
                | Jmp of Bap.Std.Bil.Types.exp
                | Special of string
                | While of Bap.Std.Bil.Types.exp *
                    Bap.Std.Bil.Types.stmt list
                | If of Bap.Std.Bil.Types.exp * Bap.Std.Bil.Types.stmt list *
                    Bap.Std.Bil.Types.stmt list
                | CpuExn of int
              val bin_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_stmt : stmt Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_stmt__ :
                (int -> stmt) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_stmt :
                stmt Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_stmt : stmt Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_stmt : stmt Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_stmt :
                stmt Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_stmt : Core_kernel.Std.Bin_prot.Shape.t
              val compare_stmt : stmt -> stmt -> int
              val stmt_of_sexp : Sexplib.Sexp.t -> stmt
              val sexp_of_stmt : stmt -> Sexplib.Sexp.t
            end
          type var = Types.var
          type cast = Types.cast = UNSIGNED | SIGNED | HIGH | LOW
          val bin_cast : cast Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_cast : cast Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_cast__ :
            (int -> cast) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_cast :
            cast Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_cast : cast Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_cast : cast Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_cast :
            cast Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_cast : Core_kernel.Std.Bin_prot.Shape.t
          val compare_cast : cast -> cast -> int
          val cast_of_sexp : Sexplib.Sexp.t -> cast
          val sexp_of_cast : cast -> Sexplib.Sexp.t
          type binop =
            Types.binop =
              PLUS
            | MINUS
            | TIMES
            | DIVIDE
            | SDIVIDE
            | MOD
            | SMOD
            | LSHIFT
            | RSHIFT
            | ARSHIFT
            | AND
            | OR
            | XOR
            | EQ
            | NEQ
            | LT
            | LE
            | SLT
            | SLE
          val bin_binop : binop Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_binop : binop Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_binop__ :
            (int -> binop) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_binop :
            binop Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_binop : binop Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_binop : binop Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_binop :
            binop Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_binop : Core_kernel.Std.Bin_prot.Shape.t
          val compare_binop : binop -> binop -> int
          val binop_of_sexp : Sexplib.Sexp.t -> binop
          val sexp_of_binop : binop -> Sexplib.Sexp.t
          type unop = Types.unop = NEG | NOT
          val bin_unop : unop Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_unop : unop Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_unop__ :
            (int -> unop) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_unop :
            unop Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_unop : unop Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_unop : unop Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_unop :
            unop Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_unop : Core_kernel.Std.Bin_prot.Shape.t
          val compare_unop : unop -> unop -> int
          val unop_of_sexp : Sexplib.Sexp.t -> unop
          val sexp_of_unop : unop -> Sexplib.Sexp.t
          type exp =
            Types.exp =
              Load of exp * exp * endian * size
            | Store of exp * exp * exp * endian * size
            | BinOp of binop * exp * exp
            | UnOp of unop * exp
            | Var of var
            | Int of word
            | Cast of cast * int * exp
            | Let of var * exp * exp
            | Unknown of Trie.String.Suffix.key * typ
            | Ite of exp * exp * exp
            | Extract of int * int * exp
            | Concat of exp * exp
          and typ = Types.typ = Imm of int | Mem of addr_size * size
          val bin_exp : exp Core_kernel.Std.Bin_prot.Type_class.t
          val bin_typ : typ Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_exp : exp Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_exp__ :
            (int -> exp) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_exp : exp Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_read_typ : typ Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_typ__ :
            (int -> typ) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_typ : typ Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_exp : exp Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_exp : exp Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_exp : exp Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_size_typ : typ Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_typ : typ Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_typ : typ Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_exp : Core_kernel.Std.Bin_prot.Shape.t
          val bin_shape_typ : Core_kernel.Std.Bin_prot.Shape.t
          val compare_exp : exp -> exp -> int
          val compare_typ : typ -> typ -> int
          val exp_of_sexp : Sexplib.Sexp.t -> exp
          val typ_of_sexp : Sexplib.Sexp.t -> typ
          val sexp_of_exp : exp -> Sexplib.Sexp.t
          val sexp_of_typ : typ -> Sexplib.Sexp.t
          type stmt =
            Types.stmt =
              Move of var * exp
            | Jmp of exp
            | Special of Trie.String.Suffix.key
            | While of exp * stmt list
            | If of exp * stmt list * stmt list
            | CpuExn of int
          val bin_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_stmt : stmt Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_stmt__ :
            (int -> stmt) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_stmt :
            stmt Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_stmt : stmt Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_stmt : stmt Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_stmt :
            stmt Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_stmt : Core_kernel.Std.Bin_prot.Shape.t
          val compare_stmt : stmt -> stmt -> int
          val stmt_of_sexp : Sexplib.Sexp.t -> stmt
          val sexp_of_stmt : stmt -> Sexplib.Sexp.t
          type t = stmt list
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val compare : t -> t -> int
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          type var_compare
          type vars = (var, Bap.Std.Bil.var_compare) Core_kernel.Std.Set.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val pp_binop : binop Regular.Std.printer
          val pp_unop : unop Regular.Std.printer
          val pp_cast : cast Regular.Std.printer
          val string_of_binop : binop -> string
          val string_of_unop : unop -> string
          val string_of_cast : cast -> string
          module Infix :
            sig
              val ( := ) : var -> exp -> stmt
              val ( + ) : exp -> exp -> exp
              val ( - ) : exp -> exp -> exp
              val ( * ) : exp -> exp -> exp
              val ( / ) : exp -> exp -> exp
              val ( /$ ) : exp -> exp -> exp
              val ( mod ) : exp -> exp -> exp
              val ( %$ ) : exp -> exp -> exp
              val ( lsl ) : exp -> exp -> exp
              val ( lsr ) : exp -> exp -> exp
              val ( asr ) : exp -> exp -> exp
              val ( land ) : exp -> exp -> exp
              val ( lor ) : exp -> exp -> exp
              val ( lxor ) : exp -> exp -> exp
              val lnot : exp -> exp
              val ( = ) : exp -> exp -> exp
              val ( <> ) : exp -> exp -> exp
              val ( < ) : exp -> exp -> exp
              val ( > ) : exp -> exp -> exp
              val ( <= ) : exp -> exp -> exp
              val ( >= ) : exp -> exp -> exp
              val ( <$ ) : exp -> exp -> exp
              val ( >$ ) : exp -> exp -> exp
              val ( <=$ ) : exp -> exp -> exp
              val ( >=$ ) : exp -> exp -> exp
              val ( ^ ) : exp -> exp -> exp
            end
          val ( := ) : var -> exp -> stmt
          val ( + ) : exp -> exp -> exp
          val ( - ) : exp -> exp -> exp
          val ( * ) : exp -> exp -> exp
          val ( / ) : exp -> exp -> exp
          val ( /$ ) : exp -> exp -> exp
          val ( mod ) : exp -> exp -> exp
          val ( %$ ) : exp -> exp -> exp
          val ( lsl ) : exp -> exp -> exp
          val ( lsr ) : exp -> exp -> exp
          val ( asr ) : exp -> exp -> exp
          val ( land ) : exp -> exp -> exp
          val ( lor ) : exp -> exp -> exp
          val ( lxor ) : exp -> exp -> exp
          val lnot : exp -> exp
          val ( = ) : exp -> exp -> exp
          val ( <> ) : exp -> exp -> exp
          val ( < ) : exp -> exp -> exp
          val ( > ) : exp -> exp -> exp
          val ( <= ) : exp -> exp -> exp
          val ( >= ) : exp -> exp -> exp
          val ( <$ ) : exp -> exp -> exp
          val ( >$ ) : exp -> exp -> exp
          val ( <=$ ) : exp -> exp -> exp
          val ( >=$ ) : exp -> exp -> exp
          val ( ^ ) : exp -> exp -> exp
          val move : var -> exp -> stmt
          val jmp : exp -> stmt
          val special : string -> stmt
          val while_ : exp -> stmt list -> stmt
          val if_ : exp -> stmt list -> stmt list -> stmt
          val cpuexn : int -> stmt
          val unsigned : cast
          val signed : cast
          val high : cast
          val low : cast
          val plus : binop
          val minus : binop
          val times : binop
          val divide : binop
          val sdivide : binop
          val modulo : binop
          val smodulo : binop
          val lshift : binop
          val rshift : binop
          val arshift : binop
          val bit_and : binop
          val bit_or : binop
          val bit_xor : binop
          val eq : binop
          val neq : binop
          val lt : binop
          val le : binop
          val slt : binop
          val sle : binop
          val neg : unop
          val not : unop
          val load :
            mem:exp -> addr:exp -> Bap.Std.endian -> Bap.Std.size -> exp
          val store :
            mem:exp ->
            addr:exp -> exp -> Bap.Std.endian -> Bap.Std.size -> exp
          val binop : binop -> exp -> exp -> exp
          val unop : unop -> exp -> exp
          val var : var -> exp
          val int : Bap.Std.word -> exp
          val cast : cast -> int -> exp -> exp
          val let_ : var -> exp -> exp -> exp
          val unknown : string -> typ -> exp
          val ite : if_:exp -> then_:exp -> else_:exp -> exp
          val extract : hi:int -> lo:int -> exp -> exp
          val concat : exp -> exp -> exp
          val is_referenced : var -> stmt list -> bool
          val is_assigned : ?strict:bool -> var -> stmt list -> bool
          val prune_unreferenced :
            ?such_that:(var -> bool) ->
            ?physicals:bool -> ?virtuals:bool -> stmt list -> stmt list
          val normalize_negatives : stmt list -> stmt list
          val substitute : exp -> exp -> stmt list -> stmt list
          val substitute_var : var -> exp -> stmt list -> stmt list
          val free_vars : stmt list -> Bap.Std.Bil.vars
          val fold_consts : stmt list -> stmt list
          val fixpoint : (stmt list -> stmt list) -> stmt list -> stmt list
          val propagate_consts : stmt list -> stmt list
          val prune_dead_virtuals : stmt list -> stmt list
          module Apply :
            sig
              val binop :
                binop -> Bap.Std.word -> Bap.Std.word -> Bap.Std.word
              val unop : unop -> Bap.Std.word -> Bap.Std.word
              val cast : cast -> int -> Bap.Std.word -> Bap.Std.word
            end
          type result
          class type storage =
            object ('a)
              method load : Bap.Std.addr -> Bap.Std.word option
              method save : Bap.Std.addr -> Bap.Std.word -> 'a
            end
          module Storage :
            sig class linear : storage class sparse : storage end
          type value = Imm of Bap.Std.word | Mem of Bap.Std.Bil.storage | Bot
          module Result :
            sig
              type id
              type t = Bap.Std.Bil.result
              type 'a r = (Bap.Std.Bil.result, 'a) Monads.Std.Monad.State.t
              type 'a u = (unit, 'a) Monads.Std.Monad.State.t
              val undefined : Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
              val storage :
                Bap.Std.Bil.storage ->
                Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
              val word :
                Bap.Std.word -> Bap.Std.Bil.Result.id -> Bap.Std.Bil.Result.t
              val id : Bap.Std.Bil.Result.t -> Bap.Std.Bil.Result.id
              val value : Bap.Std.Bil.Result.t -> Bap.Std.Bil.value
              module Id :
                sig
                  type t = id
                  val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (int -> t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val to_string : t -> Trie.String.Suffix.key
                  val str : unit -> t -> Trie.String.Suffix.key
                  val pps : unit -> t -> Trie.String.Suffix.key
                  val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                  val pp_seq : Format.formatter -> t Seq.t -> unit
                  val pp : Base__.Import.Caml.Format.formatter -> t -> unit
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = id
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (id, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : id -> '-> 'a t
                          val of_alist :
                            (id * 'a) list ->
                            [ `Duplicate_key of id | `Ok of 'a t ]
                          val of_alist_or_error :
                            (id * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (id * 'a) list -> 'a t
                          val of_alist_multi : (id * 'a) list -> 'a list t
                          val of_alist_fold :
                            (id * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (id * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (id * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (id * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> id * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of id | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:id -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:id -> data:'-> 'a list t
                          val remove_multi : 'a list t -> id -> 'a list t
                          val change :
                            'a t -> id -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> id -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> id -> 'a option
                          val find_exn : 'a t -> id -> 'a
                          val remove : 'a t -> id -> 'a t
                          val mem : 'a t -> id -> bool
                          val iter_keys : 'a t -> f:(id -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:id -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:id ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:id -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:id -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:id ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:id -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> id list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (id * 'a) list
                          val validate :
                            name:(id -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:id ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (id, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (id * 'a) option
                          val min_elt_exn : 'a t -> id * 'a
                          val max_elt : 'a t -> (id * 'a) option
                          val max_elt_exn : 'a t -> id * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:id -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:id -> data:'-> bool) -> int
                          val split :
                            'a t -> id -> 'a t * (id * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:id Base__.Maybe_bound.t ->
                            upper_bound:id Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:id ->
                            max:id ->
                            init:'->
                            f:(key:id -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:id -> max:id -> (id * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> id -> (id * 'a) option
                          val nth : 'a t -> int -> (id * 'a) option
                          val nth_exn : 'a t -> int -> id * 'a
                          val rank : 'a t -> id -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:id ->
                            ?keys_less_or_equal_to:id ->
                            'a t -> (id * 'a) Base__.Sequence.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> id
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (id, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : id -> '-> 'a t
                      val of_alist :
                        (id * 'a) list ->
                        [ `Duplicate_key of id | `Ok of 'a t ]
                      val of_alist_or_error :
                        (id * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (id * 'a) list -> 'a t
                      val of_alist_multi : (id * 'a) list -> 'a list t
                      val of_alist_fold :
                        (id * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (id * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (id * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked : (id * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:id -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of id | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (id, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:id -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:id -> data:'-> 'a list t
                      val remove_multi : 'a list t -> id -> 'a list t
                      val change :
                        'a t -> id -> f:('a option -> 'a option) -> 'a t
                      val update : 'a t -> id -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> id -> 'a option
                      val find_exn : 'a t -> id -> 'a
                      val remove : 'a t -> id -> 'a t
                      val mem : 'a t -> id -> bool
                      val iter_keys : 'a t -> f:(id -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:id -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi : 'a t -> f:(key:id -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:id ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(id -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:id -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:id -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t -> f:(key:id -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> id list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (id * 'a) list
                      val validate :
                        name:(id -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:id ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (id, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (id * 'a) option
                      val min_elt_exn : 'a t -> id * 'a
                      val max_elt : 'a t -> (id * 'a) option
                      val max_elt_exn : 'a t -> id * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:id -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:id -> data:'-> bool) -> int
                      val split :
                        'a t -> id -> 'a t * (id * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:id Base__.Maybe_bound.t ->
                        upper_bound:id Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:id ->
                        max:id ->
                        init:'-> f:(key:id -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:id -> max:id -> (id * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> id -> (id * 'a) option
                      val nth : 'a t -> int -> (id * 'a) option
                      val nth_exn : 'a t -> int -> id * 'a
                      val rank : 'a t -> id -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:id ->
                        ?keys_less_or_equal_to:id ->
                        'a t -> (id * 'a) Base__.Sequence.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : id Bin_prot.Type_class.t
                                   val bin_read_t : id Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> id)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     id Bin_prot.Type_class.reader
                                   val bin_size_t : id Bin_prot.Size.sizer
                                   val bin_write_t : id Bin_prot.Write.writer
                                   val bin_writer_t :
                                     id Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     id -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = id
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (id, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(id -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(id -> bool) -> bool
                          val for_all : t -> f:(id -> bool) -> bool
                          val count : t -> f:(id -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(id -> 'sum) -> 'sum
                          val find : t -> f:(id -> bool) -> id option
                          val find_map :
                            t -> f:(id -> 'a option) -> 'a option
                          val to_list : t -> id list
                          val to_array : t -> id array
                          val invariants : t -> bool
                          val mem : t -> id -> bool
                          val add : t -> id -> t
                          val remove : t -> id -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t -> (id, id) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               id ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(id -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of id * id
                               | `Left of id
                               | `Right of id ] -> unit) ->
                            unit
                          val filter : t -> f:(id -> bool) -> t
                          val partition_tf : t -> f:(id -> bool) -> t * t
                          val elements : t -> id list
                          val min_elt : t -> id option
                          val min_elt_exn : t -> id
                          val max_elt : t -> id option
                          val max_elt_exn : t -> id
                          val choose : t -> id option
                          val choose_exn : t -> id
                          val split : t -> id -> t * id option * t
                          val group_by :
                            t -> equiv:(id -> id -> bool) -> t list
                          val find_exn : t -> f:(id -> bool) -> id
                          val find_index : t -> int -> id option
                          val nth : t -> int -> id option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:id ->
                            ?less_or_equal_to:id ->
                            t ->
                            t ->
                            (id, id)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(id -> 'data) ->
                            (id, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            id Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            id Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : id -> t
                          val union_list : t list -> t
                          val of_list : id list -> t
                          val of_array : id array -> t
                          val of_sorted_array :
                            id array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : id array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> id) -> t
                          val stable_dedup_list : id list -> id list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> id) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> id option) -> t
                          val of_tree : t -> t
                          val of_hash_set : id Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (id, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            id Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> id
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (id, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(id -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> id -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> id -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(id -> bool) -> bool
                      val for_all : t -> f:(id -> bool) -> bool
                      val count : t -> f:(id -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(id -> 'sum) -> 'sum
                      val find : t -> f:(id -> bool) -> id option
                      val find_map : t -> f:(id -> 'a option) -> 'a option
                      val to_list : t -> id list
                      val to_array : t -> id array
                      val invariants : t -> bool
                      val mem : t -> id -> bool
                      val add : t -> id -> t
                      val remove : t -> id -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t -> t -> (id, id) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           id ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(id -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of id * id | `Left of id | `Right of id ] ->
                           unit) ->
                        unit
                      val filter : t -> f:(id -> bool) -> t
                      val partition_tf : t -> f:(id -> bool) -> t * t
                      val elements : t -> id list
                      val min_elt : t -> id option
                      val min_elt_exn : t -> id
                      val max_elt : t -> id option
                      val max_elt_exn : t -> id
                      val choose : t -> id option
                      val choose_exn : t -> id
                      val split : t -> id -> t * id option * t
                      val group_by : t -> equiv:(id -> id -> bool) -> t list
                      val find_exn : t -> f:(id -> bool) -> id
                      val find_index : t -> int -> id option
                      val nth : t -> int -> id option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id -> t -> id Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:id ->
                        ?less_or_equal_to:id ->
                        t ->
                        t ->
                        (id, id)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(id -> 'data) ->
                        (id, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        id Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        id Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : id -> t
                      val union_list : t list -> t
                      val of_list : id list -> t
                      val of_array : id array -> t
                      val of_sorted_array : id array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : id array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> id) -> t
                      val stable_dedup_list : id list -> id list
                      val map : ('a, 'b) Base.Set.t -> f:('-> id) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> id option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : id Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (id, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (id, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        id Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> id end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : id Bin_prot.Type_class.t
                                   val bin_read_t : id Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> id)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     id Bin_prot.Type_class.reader
                                   val bin_size_t : id Bin_prot.Size.sizer
                                   val bin_write_t : id Bin_prot.Write.writer
                                   val bin_writer_t :
                                     id Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     id -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val hashable :
                    t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl = ('a, 'b) Addr.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                      val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                      val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                      val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                      val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                      val __bin_read_t__ :
                        ('a, int -> 'a t) Bin_prot.Read.reader1
                      val bin_writer_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.writer
                      val bin_reader_t :
                        ('a, 'a t) Bin_prot.Type_class.S1.reader
                      val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                      val bin_shape_t : Bin_prot.Shape.t
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_t : t Bin_prot.Type_class.t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = id
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> id -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> id -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> id -> 'a
                      val enqueue :
                        'a t -> id -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> id -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> id -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> id -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (id * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> id Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (id * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> id * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> id -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> id -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> id -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> id -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:id -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:id -> data:'-> 'b) -> 'b
                    end
                  type info =
                      Trie.String.Suffix.key *
                      [ `Ver of Trie.String.Suffix.key ] *
                      Trie.String.Suffix.key option
                  val version : Trie.String.Suffix.key
                  val size_in_bytes :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key -> t -> int
                  val of_bytes :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
                  val to_bytes :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
                  val blit_to_bytes :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Regular.Std.bytes -> t -> int -> unit
                  val of_bigstring :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.bigstring -> t
                  val to_bigstring :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    t -> Core_kernel.Std.bigstring
                  val blit_to_bigstring :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.bigstring -> t -> int -> unit
                  module Io :
                    sig
                      val read :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        Trie.String.Suffix.key -> t
                      val load :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        Core_kernel.Std.In_channel.t -> t
                      val load_all :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
                      val scan :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        Core_kernel.Std.In_channel.t -> unit -> t option
                      val write :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        Trie.String.Suffix.key -> t -> unit
                      val save :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        Core_kernel.Std.Out_channel.t -> t -> unit
                      val save_all :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        Core_kernel.Std.Out_channel.t -> t list -> unit
                      val dump :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        Core_kernel.Std.Out_channel.t ->
                        (unit -> t option) -> unit
                      val show :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key -> t -> unit
                      val print :
                        ?ver:Trie.String.Suffix.key ->
                        ?fmt:Trie.String.Suffix.key ->
                        Format.formatter -> t -> unit
                    end
                  module Cache :
                    sig
                      val load : Regular.Std.digest -> t option
                      val save : Regular.Std.digest -> t -> unit
                    end
                  val add_reader :
                    ?desc:Trie.String.Suffix.key ->
                    ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t Regular.Std.reader -> unit
                  val add_writer :
                    ?desc:Trie.String.Suffix.key ->
                    ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t Regular.Std.writer -> unit
                  val available_readers : unit -> info list
                  val default_reader : unit -> info
                  val set_default_reader :
                    ?ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> unit
                  val with_reader :
                    ?ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> (unit -> 'a) -> 'a
                  val available_writers : unit -> info list
                  val default_writer : unit -> info
                  val set_default_writer :
                    ?ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> unit
                  val with_writer :
                    ?ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> (unit -> 'a) -> 'a
                  val default_printer : unit -> info option
                  val set_default_printer :
                    ?ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> unit
                  val with_printer :
                    ?ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> (unit -> 'a) -> 'a
                  val find_reader :
                    ?ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t Regular.Std.reader option
                  val find_writer :
                    ?ver:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t Regular.Std.writer option
                  val zero : Bap.Std.Bil.Result.t
                  val succ : Bap.Std.Bil.Result.t -> Bap.Std.Bil.Result.t
                end
              module Value :
                sig
                  type t = value
                  val to_string : t -> Trie.String.Suffix.key
                  val str : unit -> t -> Trie.String.Suffix.key
                  val pps : unit -> t -> Trie.String.Suffix.key
                  val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                  val pp_seq : Format.formatter -> t Seq.t -> unit
                  val pp : Base__.Import.Caml.Format.formatter -> t -> unit
                end
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
            end
          module Trie :
            sig
              type normalized_bil
              val normalize :
                ?subst:(exp * exp) list ->
                stmt list -> Bap.Std.Bil.Trie.normalized_bil
              module Normalized :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  type key = normalized_bil
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              type 'a t
              val bin_t :
                'Core_kernel.Std.Bin_prot.Type_class.t ->
                'a t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Std.Bin_prot.Read.reader ->
                'a t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Std.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Std.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Std.Bin_prot.Size.sizer ->
                'a t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Std.Bin_prot.Write.writer ->
                'a t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Std.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Std.Bin_prot.Shape.t ->
                Core_kernel.Std.Bin_prot.Shape.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              type key = stmt list
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          type pass
          val register_pass :
            ?desc:string ->
            string -> (Bap.Std.Bil.t -> Bap.Std.Bil.t) -> Bap.Std.Bil.pass
          val select_passes : Bap.Std.Bil.pass list -> unit
          val passes : unit -> Bap.Std.Bil.pass list
          module Pass :
            sig
              val name : Bap.Std.Bil.pass -> string
              val to_string : pass -> string
              val str : unit -> pass -> string
              val pps : unit -> pass -> string
              val ppo : Core_kernel.Std.Out_channel.t -> pass -> unit
              val pp_seq : Format.formatter -> pass Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> pass -> unit
            end
        end
      type typ = Bap.Std.Bil.typ
      val bin_typ : typ Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_typ : typ Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_typ__ :
        (int -> typ) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_typ : typ Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_typ : typ Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_typ : typ Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_typ : typ Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_typ : Core_kernel.Std.Bin_prot.Shape.t
      val compare_typ : typ -> typ -> int
      val typ_of_sexp : Sexplib.Sexp.t -> typ
      val sexp_of_typ : typ -> Sexplib.Sexp.t
      type var = Bap.Std.Bil.var
      val bin_var : var Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_var : var Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_var__ :
        (int -> var) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_var : var Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_var : var Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_var : var Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_var : var Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_var : Core_kernel.Std.Bin_prot.Shape.t
      val compare_var : var -> var -> int
      val var_of_sexp : Sexplib.Sexp.t -> var
      val sexp_of_var : var -> Sexplib.Sexp.t
      type bil = Bap.Std.Bil.t
      val bin_bil : bil Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_bil : bil Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_bil__ :
        (int -> bil) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_bil : bil Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_bil : bil Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_bil : bil Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_bil : bil Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_bil : Core_kernel.Std.Bin_prot.Shape.t
      val compare_bil : bil -> bil -> int
      val bil_of_sexp : Sexplib.Sexp.t -> bil
      val sexp_of_bil : bil -> Sexplib.Sexp.t
      type binop = Bap.Std.Bil.binop
      val bin_binop : binop Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_binop : binop Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_binop__ :
        (int -> binop) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_binop : binop Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_binop : binop Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_binop : binop Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_binop : binop Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_binop : Core_kernel.Std.Bin_prot.Shape.t
      val compare_binop : binop -> binop -> int
      val binop_of_sexp : Sexplib.Sexp.t -> binop
      val sexp_of_binop : binop -> Sexplib.Sexp.t
      type cast = Bap.Std.Bil.cast
      val bin_cast : cast Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_cast : cast Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_cast__ :
        (int -> cast) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_cast : cast Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_cast : cast Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_cast : cast Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_cast : cast Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_cast : Core_kernel.Std.Bin_prot.Shape.t
      val compare_cast : cast -> cast -> int
      val cast_of_sexp : Sexplib.Sexp.t -> cast
      val sexp_of_cast : cast -> Sexplib.Sexp.t
      type exp = Bap.Std.Bil.exp
      val bin_exp : exp Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_exp : exp Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_exp__ :
        (int -> exp) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_exp : exp Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_exp : exp Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_exp : exp Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_exp : exp Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_exp : Core_kernel.Std.Bin_prot.Shape.t
      val compare_exp : exp -> exp -> int
      val exp_of_sexp : Sexplib.Sexp.t -> exp
      val sexp_of_exp : exp -> Sexplib.Sexp.t
      type stmt = Bap.Std.Bil.stmt
      val bin_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_stmt : stmt Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_stmt__ :
        (int -> stmt) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_stmt : stmt Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_stmt : stmt Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_stmt : stmt Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_stmt : Core_kernel.Std.Bin_prot.Shape.t
      val compare_stmt : stmt -> stmt -> int
      val stmt_of_sexp : Sexplib.Sexp.t -> stmt
      val sexp_of_stmt : stmt -> Sexplib.Sexp.t
      type unop = Bap.Std.Bil.unop
      val bin_unop : unop Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_unop : unop Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_unop__ :
        (int -> unop) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_unop : unop Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_unop : unop Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_unop : unop Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_unop : unop Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_unop : Core_kernel.Std.Bin_prot.Shape.t
      val compare_unop : unop -> unop -> int
      val unop_of_sexp : Sexplib.Sexp.t -> unop
      val sexp_of_unop : unop -> Sexplib.Sexp.t
      module Type :
        sig
          type t =
            Bap.Std.Bil.typ =
              Imm of int
            | Mem of Bap.Std.addr_size * Bap.Std.size
          module Variants :
            sig
              val imm : (int -> t) Variantslib.Variant.t
              val mem : (addr_size -> size -> t) Variantslib.Variant.t
              val fold :
                init:'acc__ ->
                imm:('acc__ -> (int -> t) Variantslib.Variant.t -> 'acc__) ->
                mem:('acc__ ->
                     (addr_size -> size -> t) Variantslib.Variant.t -> 'acc__) ->
                'acc__
              val iter :
                imm:((int -> t) Variantslib.Variant.t -> unit) ->
                mem:((addr_size -> size -> t) Variantslib.Variant.t -> unit) ->
                unit
              val map :
                t ->
                imm:((int -> t) Variantslib.Variant.t -> int -> 'result__) ->
                mem:((addr_size -> size -> t) Variantslib.Variant.t ->
                     addr_size -> size -> 'result__) ->
                'result__
              val to_rank : t -> int
              val to_name : t -> Trie.String.Suffix.key
              val descriptions : (Trie.String.Suffix.key * int) list
            end
          type error
          val bin_error : error Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_error : error Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_error__ :
            (int -> error) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_error :
            error Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_error : error Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_error : error Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_error :
            error Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_error : Core_kernel.Std.Bin_prot.Shape.t
          val compare_error : error -> error -> int
          val error_of_sexp : Sexplib.Sexp.t -> error
          val sexp_of_error : error -> Sexplib.Sexp.t
          val imm : int -> Bap.Std.Type.t
          val mem : Bap.Std.addr_size -> Bap.Std.size -> Bap.Std.Type.t
          val infer :
            Bap.Std.exp ->
            (Bap.Std.Type.t, Bap.Std.Type.error) Core_kernel.Std.Result.t
          val infer_exn : Bap.Std.exp -> Bap.Std.Type.t
          val check :
            Bap.Std.bil ->
            (unit, Bap.Std.Type.error) Core_kernel.Std.Result.t
          module Error :
            sig
              type t = Bap.Std.Type.error
              exception T of Bap.Std.Type.Error.t
              val bad_mem : Bap.Std.Type.Error.t
              val bad_imm : Bap.Std.Type.Error.t
              val bad_cast : Bap.Std.Type.Error.t
              val bad_type :
                exp:Bap.Std.typ -> got:Bap.Std.typ -> Bap.Std.Type.Error.t
              val expect_mem : unit -> 'a
              val expect_imm : unit -> 'a
              val wrong_cast : unit -> 'a
              val expect : Bap.Std.typ -> got:Bap.Std.typ -> 'a
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
              module Map :
                sig
                  module Key :
                    sig
                      type t = Bap.Std.Type.error
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (Key.t, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : Key.t -> '-> 'a t
                      val of_alist :
                        (Key.t * 'a) list ->
                        [ `Duplicate_key of Key.t | `Ok of 'a t ]
                      val of_alist_or_error :
                        (Key.t * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (Key.t * 'a) list -> 'a t
                      val of_alist_multi : (Key.t * 'a) list -> 'a list t
                      val of_alist_fold :
                        (Key.t * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (Key.t * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (Key.t * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Key.t * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of Key.t | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        Key.t Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:Key.t -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:Key.t -> data:'-> 'a list t
                      val remove_multi : 'a list t -> Key.t -> 'a list t
                      val change :
                        'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> Key.t -> 'a option
                      val find_exn : 'a t -> Key.t -> 'a
                      val remove : 'a t -> Key.t -> 'a t
                      val mem : 'a t -> Key.t -> bool
                      val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:Key.t ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> Key.t list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (Key.t * 'a) list
                      val validate :
                        name:(Key.t -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (Key.t, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (Key.t * 'a) option
                      val min_elt_exn : 'a t -> Key.t * 'a
                      val max_elt : 'a t -> (Key.t * 'a) option
                      val max_elt_exn : 'a t -> Key.t * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> int
                      val split :
                        'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:Key.t Base__.Maybe_bound.t ->
                        upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:Key.t ->
                        max:Key.t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> Key.t -> (Key.t * 'a) option
                      val nth : 'a t -> int -> (Key.t * 'a) option
                      val nth_exn : 'a t -> int -> Key.t * 'a
                      val rank : 'a t -> Key.t -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:Key.t ->
                        ?keys_less_or_equal_to:Key.t ->
                        'a t -> (Key.t * 'a) Base__.Sequence.t
                      val obs :
                        Key.t Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : Key.t Bin_prot.Type_class.t
                               val bin_read_t : Key.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Key.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Key.t Bin_prot.Type_class.reader
                               val bin_size_t : Key.t Bin_prot.Size.sizer
                               val bin_write_t : Key.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Key.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Key.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = Map.Key.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (Elt.t, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(Elt.t -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(Elt.t -> bool) -> bool
                      val for_all : t -> f:(Elt.t -> bool) -> bool
                      val count : t -> f:(Elt.t -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(Elt.t -> 'sum) -> 'sum
                      val find : t -> f:(Elt.t -> bool) -> Elt.t option
                      val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                      val to_list : t -> Elt.t list
                      val to_array : t -> Elt.t array
                      val invariants : t -> bool
                      val mem : t -> Elt.t -> bool
                      val add : t -> Elt.t -> t
                      val remove : t -> Elt.t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           Elt.t ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of Elt.t * Elt.t
                           | `Left of Elt.t
                           | `Right of Elt.t ] -> unit) ->
                        unit
                      val filter : t -> f:(Elt.t -> bool) -> t
                      val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                      val elements : t -> Elt.t list
                      val min_elt : t -> Elt.t option
                      val min_elt_exn : t -> Elt.t
                      val max_elt : t -> Elt.t option
                      val max_elt_exn : t -> Elt.t
                      val choose : t -> Elt.t option
                      val choose_exn : t -> Elt.t
                      val split : t -> Elt.t -> t * Elt.t option * t
                      val group_by :
                        t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                      val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                      val find_index : t -> int -> Elt.t option
                      val nth : t -> int -> Elt.t option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t -> Elt.t Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t ->
                        t ->
                        (Elt.t, Elt.t)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(Elt.t -> 'data) ->
                        (Elt.t, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        Elt.t Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : Elt.t -> t
                      val union_list : t list -> t
                      val of_list : Elt.t list -> t
                      val of_array : Elt.t array -> t
                      val of_sorted_array :
                        Elt.t array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : Elt.t array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Elt.t) -> t
                      val stable_dedup_list : Elt.t list -> Elt.t list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t option) -> t
                      val of_tree : t -> t
                      val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (Elt.t, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        Elt.t Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (Elt.t, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : Elt.t Bin_prot.Type_class.t
                               val bin_read_t : Elt.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Elt.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Elt.t Bin_prot.Type_class.reader
                               val bin_size_t : Elt.t Bin_prot.Size.sizer
                               val bin_write_t : Elt.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Elt.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Elt.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              val hash : t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Addr.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = Hash_set.elt
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> Key.t -> 'a
                  val enqueue :
                    'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> Key.t Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> Key.t * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
                  val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                end
              type info =
                  Trie.String.Suffix.key *
                  [ `Ver of Trie.String.Suffix.key ] *
                  Trie.String.Suffix.key option
              val version : Trie.String.Suffix.key
              val size_in_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> int
              val of_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
              val to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
              val blit_to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Regular.Std.bytes -> t -> int -> unit
              val of_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
              val to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
              val blit_to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.bigstring -> t -> int -> unit
              module Io :
                sig
                  val read :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t
                  val load :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.In_channel.t -> t
                  val load_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
                  val scan :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.In_channel.t -> unit -> t option
                  val write :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t -> unit
                  val save :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t -> t -> unit
                  val save_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t -> t list -> unit
                  val dump :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t ->
                    (unit -> t option) -> unit
                  val show :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key -> t -> unit
                  val print :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Format.formatter -> t -> unit
                end
              module Cache :
                sig
                  val load : Regular.Std.digest -> t option
                  val save : Regular.Std.digest -> t -> unit
                end
              val add_reader :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader -> unit
              val add_writer :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer -> unit
              val available_readers : unit -> info list
              val default_reader : unit -> info
              val set_default_reader :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val available_writers : unit -> info list
              val default_writer : unit -> info
              val set_default_writer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val default_printer : unit -> info option
              val set_default_printer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_printer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val find_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader option
              val find_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer option
            end
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.Bil.typ
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Error.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      val bool_t : Bap.Std.typ
      val reg8_t : Bap.Std.typ
      val reg16_t : Bap.Std.typ
      val reg32_t : Bap.Std.typ
      val reg64_t : Bap.Std.typ
      val reg128_t : Bap.Std.typ
      val reg256_t : Bap.Std.typ
      val mem32_t : Bap.Std.size -> Bap.Std.typ
      val mem64_t : Bap.Std.size -> Bap.Std.typ
      module Var :
        sig
          type t = Bap.Std.var
          val create :
            ?is_virtual:bool ->
            ?fresh:bool -> string -> Bap.Std.typ -> Bap.Std.Var.t
          val name : Bap.Std.Var.t -> string
          val typ : Bap.Std.Var.t -> Bap.Std.typ
          val is_physical : Bap.Std.Var.t -> bool
          val is_virtual : Bap.Std.Var.t -> bool
          val with_index : Bap.Std.Var.t -> int -> Bap.Std.Var.t
          val index : Bap.Std.Var.t -> int
          val base : Bap.Std.Var.t -> Bap.Std.Var.t
          val same : Bap.Std.Var.t -> Bap.Std.Var.t -> bool
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness = Bil.var_compare
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.var
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = Bil.var_compare
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Bil.var_compare
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Type.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Context :
        sig
          class t :
            object ('a)
              method bindings :
                (Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
              method lookup : Bap.Std.var -> Bap.Std.Bil.result option
              method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
            end
        end
      module Type_error :
        sig
          type t = Type.Error.t
          exception T of t
          val bad_mem : t
          val bad_imm : t
          val bad_cast : t
          val bad_type : exp:typ -> got:typ -> t
          val expect_mem : unit -> 'a
          val expect_imm : unit -> 'a
          val wrong_cast : unit -> 'a
          val expect : typ -> got:typ -> 'a
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Type.Error.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Var.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      type type_error = Bap.Std.Type_error.t
      val bin_type_error : type_error Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_type_error :
        type_error Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_type_error__ :
        (int -> type_error) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_type_error :
        type_error Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_type_error :
        type_error Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_type_error :
        type_error Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_type_error :
        type_error Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_type_error : Core_kernel.Std.Bin_prot.Shape.t
      val compare_type_error : type_error -> type_error -> int
      val type_error_of_sexp : Sexplib.Sexp.t -> type_error
      val sexp_of_type_error : type_error -> Sexplib.Sexp.t
      module Eval :
        sig
          module T1 :
            functor (M : Core_kernel.Std.T1->
              sig
                type 'a m = 'M.t
                class type ['r] semantics =
                  object
                    method eval_binop :
                      Bap.Std.binop ->
                      Bap.Std.exp -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                    method eval_cast :
                      Bap.Std.cast ->
                      int -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                    method eval_concat :
                      Bap.Std.exp -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                    method eval_exp : Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                    method eval_extract :
                      int -> int -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                    method eval_int : Bap.Std.word -> 'Bap.Std.Eval.T1.m
                    method eval_ite :
                      cond:Bap.Std.exp ->
                      yes:Bap.Std.exp ->
                      no:Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                    method eval_let :
                      Bap.Std.var ->
                      Bap.Std.exp -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                    method eval_load :
                      mem:Bap.Std.exp ->
                      addr:Bap.Std.exp ->
                      Bap.Std.endian -> Bap.Std.size -> 'Bap.Std.Eval.T1.m
                    method eval_store :
                      mem:Bap.Std.exp ->
                      addr:Bap.Std.exp ->
                      Bap.Std.exp ->
                      Bap.Std.endian -> Bap.Std.size -> 'Bap.Std.Eval.T1.m
                    method eval_unknown :
                      string -> Bap.Std.typ -> 'Bap.Std.Eval.T1.m
                    method eval_unop :
                      Bap.Std.unop -> Bap.Std.exp -> 'Bap.Std.Eval.T1.m
                    method eval_var : Bap.Std.var -> 'Bap.Std.Eval.T1.m
                  end
                class type virtual ['r, 's] domain =
                  object
                    method private virtual storage_of_value :
                      '-> 's option Bap.Std.Eval.T1.m
                    method private virtual undefined : 'Bap.Std.Eval.T1.m
                    method private virtual value_of_word :
                      Bap.Std.word -> 'Bap.Std.Eval.T1.m
                    method private virtual word_of_value :
                      '-> Bap.Std.word option Bap.Std.Eval.T1.m
                  end
                class type virtual ['r, 's] eff =
                  object
                    method virtual load :
                      '-> Bap.Std.addr -> 'Bap.Std.Eval.T1.m
                    method virtual lookup :
                      Bap.Std.var -> 'Bap.Std.Eval.T1.m
                    method virtual store :
                      '->
                      Bap.Std.addr -> Bap.Std.word -> 'Bap.Std.Eval.T1.m
                    method virtual update :
                      Bap.Std.var -> '-> unit Bap.Std.Eval.T1.m
                  end
              end
          module T2 :
            functor (M : Core_kernel.Std.T2->
              sig
                type ('a, 'e) m = ('a, 'e) M.t
                class type ['a, 'r] semantics =
                  object
                    method eval_binop :
                      Bap.Std.binop ->
                      Bap.Std.exp ->
                      Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_cast :
                      Bap.Std.cast ->
                      int -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_concat :
                      Bap.Std.exp ->
                      Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_exp :
                      Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_extract :
                      int -> int -> Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_int :
                      Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_ite :
                      cond:Bap.Std.exp ->
                      yes:Bap.Std.exp ->
                      no:Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_let :
                      Bap.Std.var ->
                      Bap.Std.exp ->
                      Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_load :
                      mem:Bap.Std.exp ->
                      addr:Bap.Std.exp ->
                      Bap.Std.endian ->
                      Bap.Std.size -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_store :
                      mem:Bap.Std.exp ->
                      addr:Bap.Std.exp ->
                      Bap.Std.exp ->
                      Bap.Std.endian ->
                      Bap.Std.size -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_unknown :
                      string -> Bap.Std.typ -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_unop :
                      Bap.Std.unop ->
                      Bap.Std.exp -> ('r, 'a) Bap.Std.Eval.T2.m
                    method eval_var :
                      Bap.Std.var -> ('r, 'a) Bap.Std.Eval.T2.m
                  end
                class type virtual ['a, 'r, 's] domain =
                  object
                    method private virtual storage_of_value :
                      '-> ('s option, 'a) Bap.Std.Eval.T2.m
                    method private virtual undefined :
                      ('r, 'a) Bap.Std.Eval.T2.m
                    method private virtual value_of_word :
                      Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
                    method private virtual word_of_value :
                      '-> (Bap.Std.word option, 'a) Bap.Std.Eval.T2.m
                  end
                class type virtual ['a, 'r, 's] eff =
                  object
                    method virtual load :
                      '-> Bap.Std.addr -> ('r, 'a) Bap.Std.Eval.T2.m
                    method virtual lookup :
                      Bap.Std.var -> ('r, 'a) Bap.Std.Eval.T2.m
                    method virtual store :
                      '->
                      Bap.Std.addr ->
                      Bap.Std.word -> ('r, 'a) Bap.Std.Eval.T2.m
                    method virtual update :
                      Bap.Std.var -> '-> (unit, 'a) Bap.Std.Eval.T2.m
                  end
              end
          module type S =
            sig
              type 'a m
              module M : sig type 'a t = 'a m end
              class type ['r] semantics = ['r] T1(M).semantics
              class type virtual ['r, 's] domain = ['r, 's] T1(M).domain
              class type virtual ['r, 's] eff = ['r, 's] T1(M).eff
              class virtual ['r, 's] t :
                object
                  method division_by_zero : unit -> 'Bap.Std.Eval.S.m
                  method eval_binop : binop -> exp -> exp -> 'M.t
                  method eval_cast : cast -> int -> exp -> 'M.t
                  method eval_concat : exp -> exp -> 'M.t
                  method eval_exp : exp -> 'M.t
                  method eval_extract : int -> int -> exp -> 'M.t
                  method eval_int : word -> 'M.t
                  method eval_ite : cond:exp -> yes:exp -> no:exp -> 'M.t
                  method eval_let : var -> exp -> exp -> 'M.t
                  method eval_load :
                    mem:exp -> addr:exp -> endian -> size -> 'M.t
                  method eval_store :
                    mem:exp -> addr:exp -> exp -> endian -> size -> 'M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> 'M.t
                  method eval_unop : unop -> exp -> 'M.t
                  method eval_var : var -> 'M.t
                  method virtual load : '-> addr -> 'M.t
                  method virtual lookup : var -> 'M.t
                  method private virtual storage_of_value :
                    '-> 's option M.t
                  method virtual store : '-> addr -> word -> 'M.t
                  method type_error :
                    Bap.Std.type_error -> 'Bap.Std.Eval.S.m
                  method private virtual undefined : 'M.t
                  method virtual update : var -> '-> unit M.t
                  method private virtual value_of_word : word -> 'M.t
                  method private virtual word_of_value :
                    '-> word option M.t
                end
            end
          module type S2 =
            sig
              type ('a, 'e) m
              module M : sig type ('a, 'e) t = ('a, 'e) m end
              class type ['a, 'r] semantics = ['a, 'r] T2(M).semantics
              class type virtual ['a, 'r, 's] domain =
                ['a, 'r, 's] T2(M).domain
              class type virtual ['a, 'r, 's] eff = ['a, 'r, 's] T2(M).eff
              class virtual ['a, 'r, 's] t :
                object
                  method division_by_zero :
                    unit -> ('r, 'a) Bap.Std.Eval.S2.m
                  method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                  method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                  method eval_concat : exp -> exp -> ('r, 'a) M.t
                  method eval_exp : exp -> ('r, 'a) M.t
                  method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                  method eval_int : word -> ('r, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                  method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                  method eval_load :
                    mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                  method eval_unop : unop -> exp -> ('r, 'a) M.t
                  method eval_var : var -> ('r, 'a) M.t
                  method virtual load : '-> addr -> ('r, 'a) M.t
                  method virtual lookup : var -> ('r, 'a) M.t
                  method private virtual storage_of_value :
                    '-> ('s option, 'a) M.t
                  method virtual store : '-> addr -> word -> ('r, 'a) M.t
                  method type_error :
                    Bap.Std.type_error -> ('r, 'a) Bap.Std.Eval.S2.m
                  method private virtual undefined : ('r, 'a) M.t
                  method virtual update : var -> '-> (unit, 'a) M.t
                  method private virtual value_of_word : word -> ('r, 'a) M.t
                  method private virtual word_of_value :
                    '-> (word option, 'a) M.t
                end
            end
          module Make2 :
            functor (M : Monads.Std.Monad.S2->
              sig
                class type ['a, 'r] semantics = ['a, 'r] T2(M).semantics
                class type virtual ['a, 'r, 's] domain =
                  ['a, 'r, 's] T2(M).domain
                class type virtual ['a, 'r, 's] eff = ['a, 'r, 's] T2(M).eff
                class virtual ['a, 'r, 's] t :
                  object
                    method division_by_zero : unit -> ('r, 'a) M.t
                    method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                    method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                    method eval_concat : exp -> exp -> ('r, 'a) M.t
                    method eval_exp : exp -> ('r, 'a) M.t
                    method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                    method eval_int : word -> ('r, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                    method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                    method eval_load :
                      mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                    method eval_store :
                      mem:exp ->
                      addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                    method eval_unop : unop -> exp -> ('r, 'a) M.t
                    method eval_var : var -> ('r, 'a) M.t
                    method virtual load : '-> addr -> ('r, 'a) M.t
                    method virtual lookup : var -> ('r, 'a) M.t
                    method private virtual storage_of_value :
                      '-> ('s option, 'a) M.t
                    method virtual store : '-> addr -> word -> ('r, 'a) M.t
                    method type_error : type_error -> ('r, 'a) M.t
                    method private virtual undefined : ('r, 'a) M.t
                    method virtual update : var -> '-> (unit, 'a) M.t
                    method private virtual value_of_word :
                      word -> ('r, 'a) M.t
                    method private virtual word_of_value :
                      '-> (word option, 'a) M.t
                  end
              end
          module Make :
            functor (M : Monads.Std.Monad.S->
              sig
                class type ['r] semantics = ['r] T1(M).semantics
                class type virtual ['r, 's] domain = ['r, 's] T1(M).domain
                class type virtual ['r, 's] eff = ['r, 's] T1(M).eff
                class virtual ['r, 's] t :
                  object
                    method division_by_zero : unit -> 'M.t
                    method eval_binop : binop -> exp -> exp -> 'M.t
                    method eval_cast : cast -> int -> exp -> 'M.t
                    method eval_concat : exp -> exp -> 'M.t
                    method eval_exp : exp -> 'M.t
                    method eval_extract : int -> int -> exp -> 'M.t
                    method eval_int : word -> 'M.t
                    method eval_ite : cond:exp -> yes:exp -> no:exp -> 'M.t
                    method eval_let : var -> exp -> exp -> 'M.t
                    method eval_load :
                      mem:exp -> addr:exp -> endian -> size -> 'M.t
                    method eval_store :
                      mem:exp -> addr:exp -> exp -> endian -> size -> 'M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> 'M.t
                    method eval_unop : unop -> exp -> 'M.t
                    method eval_var : var -> 'M.t
                    method virtual load : '-> addr -> 'M.t
                    method virtual lookup : var -> 'M.t
                    method private virtual storage_of_value :
                      '-> 's option M.t
                    method virtual store : '-> addr -> word -> 'M.t
                    method type_error : type_error -> 'M.t
                    method private virtual undefined : 'M.t
                    method virtual update : var -> '-> unit M.t
                    method private virtual value_of_word : word -> 'M.t
                    method private virtual word_of_value :
                      '-> word option M.t
                  end
              end
        end
      module Expi :
        sig
          class context :
            object ('a)
              method bindings :
                (Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
              method create_storage :
                Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
              method create_undefined : 'a * Bap.Std.Bil.result
              method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
              method lookup : Bap.Std.var -> Bap.Std.Bil.result option
              method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
            end
          module type S =
            sig
              type ('a, 'e) state
              type 'a u = (unit, 'a) Bap.Std.Expi.S.state
              type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Expi.S.state
              module M : sig type ('a, 'e) t = ('a, 'e) state end
              module Eval :
                sig
                  class type ['a, 'r] semantics =
                    ['a, 'r] Eval.T2(M).semantics
                  class type virtual ['a, 'r, 's] domain =
                    ['a, 'r, 's] Eval.T2(M).domain
                  class type virtual ['a, 'r, 's] eff =
                    ['a, 'r, 's] Eval.T2(M).eff
                  class virtual ['a, 'r, 's] t :
                    object
                      method division_by_zero : unit -> ('r, 'a) state
                      method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                      method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                      method eval_concat : exp -> exp -> ('r, 'a) M.t
                      method eval_exp : exp -> ('r, 'a) M.t
                      method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                      method eval_int : word -> ('r, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                      method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                      method eval_load :
                        mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                      method eval_unop : unop -> exp -> ('r, 'a) M.t
                      method eval_var : var -> ('r, 'a) M.t
                      method virtual load : '-> addr -> ('r, 'a) M.t
                      method virtual lookup : var -> ('r, 'a) M.t
                      method private virtual storage_of_value :
                        '-> ('s option, 'a) M.t
                      method virtual store :
                        '-> addr -> word -> ('r, 'a) M.t
                      method type_error : type_error -> ('r, 'a) state
                      method private virtual undefined : ('r, 'a) M.t
                      method virtual update : var -> '-> (unit, 'a) M.t
                      method private virtual value_of_word :
                        word -> ('r, 'a) M.t
                      method private virtual word_of_value :
                        '-> (word option, 'a) M.t
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Bap.Std.Expi.context
                  method division_by_zero : unit -> 'Bap.Std.Expi.S.r
                  method empty : Bap.Std.Bil.storage
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method load :
                    Bap.Std.Bil.storage ->
                    Bap.Std.addr -> 'Bap.Std.Expi.S.r
                  method lookup : Bap.Std.var -> 'Bap.Std.Expi.S.r
                  method store :
                    Bap.Std.Bil.storage ->
                    Bap.Std.addr -> Bap.Std.word -> 'Bap.Std.Expi.S.r
                  method type_error :
                    Bap.Std.type_error -> 'Bap.Std.Expi.S.r
                  method undefined_addr : Bap.Std.addr -> 'Bap.Std.Expi.S.r
                  method undefined_var : Bap.Std.var -> 'Bap.Std.Expi.S.r
                  method update :
                    Bap.Std.var -> Bap.Std.Bil.result -> 'Bap.Std.Expi.S.u
                end
            end
          module Make :
            functor (M : Monads.Std.Monad.State.S2->
              sig
                type ('a, 'e) state = ('a, 'e) M.t
                type 'a u = (unit, 'a) state
                type 'a r = (Bil.result, 'a) state
                module M : sig type ('a, 'e) t = ('a, 'e) state end
                module Eval :
                  sig
                    class type ['a, 'r] semantics =
                      ['a, 'r] Eval.T2(M).semantics
                    class type virtual ['a, 'r, 's] domain =
                      ['a, 'r, 's] Eval.T2(M).domain
                    class type virtual ['a, 'r, 's] eff =
                      ['a, 'r, 's] Eval.T2(M).eff
                    class virtual ['a, 'r, 's] t :
                      object
                        method division_by_zero : unit -> ('r, 'a) state
                        method eval_binop :
                          binop -> exp -> exp -> ('r, 'a) M.t
                        method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                        method eval_concat : exp -> exp -> ('r, 'a) M.t
                        method eval_exp : exp -> ('r, 'a) M.t
                        method eval_extract :
                          int -> int -> exp -> ('r, 'a) M.t
                        method eval_int : word -> ('r, 'a) M.t
                        method eval_ite :
                          cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                        method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                        method eval_load :
                          mem:exp ->
                          addr:exp -> endian -> size -> ('r, 'a) M.t
                        method eval_store :
                          mem:exp ->
                          addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                        method eval_unknown :
                          Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                        method eval_unop : unop -> exp -> ('r, 'a) M.t
                        method eval_var : var -> ('r, 'a) M.t
                        method virtual load : '-> addr -> ('r, 'a) M.t
                        method virtual lookup : var -> ('r, 'a) M.t
                        method private virtual storage_of_value :
                          '-> ('s option, 'a) M.t
                        method virtual store :
                          '-> addr -> word -> ('r, 'a) M.t
                        method type_error : type_error -> ('r, 'a) state
                        method private virtual undefined : ('r, 'a) M.t
                        method virtual update : var -> '-> (unit, 'a) M.t
                        method private virtual value_of_word :
                          word -> ('r, 'a) M.t
                        method private virtual word_of_value :
                          '-> (word option, 'a) M.t
                      end
                  end
                class ['a] t :
                  object
                    constraint 'a = #context
                    method division_by_zero : unit -> 'a r
                    method empty : Bil.storage
                    method eval_binop :
                      binop -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_cast :
                      cast -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                    method eval_exp : exp -> (Bil.result, 'a) M.t
                    method eval_extract :
                      int -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_int : word -> (Bil.result, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                    method eval_let :
                      var -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_load :
                      mem:exp ->
                      addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_store :
                      mem:exp ->
                      addr:exp ->
                      exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                    method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                    method eval_var : var -> (Bil.result, 'a) M.t
                    method load : Bil.storage -> addr -> 'a r
                    method lookup : var -> 'a r
                    method store : Bil.storage -> addr -> word -> 'a r
                    method type_error : type_error -> 'a r
                    method undefined_addr : addr -> 'a r
                    method undefined_var : var -> 'a r
                    method update : var -> Bil.result -> 'a u
                  end
              end
          type ('a, 'e) state = ('a, 'e) Legacy.Monad.State.t
          type 'a u = (unit, 'a) state
          type 'a r = (Bil.result, 'a) state
          module M : sig type ('a, 'e) t = ('a, 'e) state end
          module Eval :
            sig
              class type ['a, 'r] semantics = ['a, 'r] Eval.T2(M).semantics
              class type virtual ['a, 'r, 's] domain =
                ['a, 'r, 's] Eval.T2(M).domain
              class type virtual ['a, 'r, 's] eff =
                ['a, 'r, 's] Eval.T2(M).eff
              class virtual ['a, 'r, 's] t :
                object
                  method division_by_zero : unit -> ('r, 'a) state
                  method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                  method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                  method eval_concat : exp -> exp -> ('r, 'a) M.t
                  method eval_exp : exp -> ('r, 'a) M.t
                  method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                  method eval_int : word -> ('r, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                  method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                  method eval_load :
                    mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                  method eval_unop : unop -> exp -> ('r, 'a) M.t
                  method eval_var : var -> ('r, 'a) M.t
                  method virtual load : '-> addr -> ('r, 'a) M.t
                  method virtual lookup : var -> ('r, 'a) M.t
                  method private virtual storage_of_value :
                    '-> ('s option, 'a) M.t
                  method virtual store : '-> addr -> word -> ('r, 'a) M.t
                  method type_error : type_error -> ('r, 'a) state
                  method private virtual undefined : ('r, 'a) M.t
                  method virtual update : var -> '-> (unit, 'a) M.t
                  method private virtual value_of_word : word -> ('r, 'a) M.t
                  method private virtual word_of_value :
                    '-> (word option, 'a) M.t
                end
            end
          class ['a] t :
            object
              constraint 'a = #context
              method division_by_zero : unit -> 'a r
              method empty : Bil.storage
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method load : Bil.storage -> addr -> 'a r
              method lookup : var -> 'a r
              method store : Bil.storage -> addr -> word -> 'a r
              method type_error : type_error -> 'a r
              method undefined_addr : addr -> 'a r
              method undefined_var : var -> 'a r
              method update : var -> Bil.result -> 'a u
            end
        end
      class ['a] expi :
        object
          constraint 'a = #Bap.Std.Expi.context
          method division_by_zero : unit -> 'Expi.r
          method empty : Bil.storage
          method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
          method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
          method eval_exp : exp -> (Bil.result, 'a) M.t
          method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
          method eval_int : word -> (Bil.result, 'a) M.t
          method eval_ite :
            cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
          method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_load :
            mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_store :
            mem:exp ->
            addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_unknown :
            Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
          method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
          method eval_var : var -> (Bil.result, 'a) M.t
          method load : Bil.storage -> addr -> 'Expi.r
          method lookup : var -> 'Expi.r
          method store : Bil.storage -> addr -> word -> 'Expi.r
          method type_error : type_error -> 'Expi.r
          method undefined_addr : addr -> 'Expi.r
          method undefined_var : var -> 'Expi.r
          method update : var -> Bil.result -> 'Expi.u
        end
      module Bili :
        sig
          class context :
            object ('a)
              method bindings :
                (Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
              method create_storage :
                Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
              method create_undefined : 'a * Bap.Std.Bil.result
              method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
              method lookup : Bap.Std.var -> Bap.Std.Bil.result option
              method pc : Bap.Std.Bil.value
              method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
              method with_pc : Bap.Std.Bil.value -> 'a
            end
          module type S =
            sig
              type ('a, 'e) state
              type 'a u = (unit, 'a) Bap.Std.Bili.S.state
              type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Bili.S.state
              module Expi :
                sig
                  type ('a, 'e) state = ('a, 'e) state
                  type 'a u = (unit, 'a) state
                  type 'a r = (Bil.result, 'a) state
                  module M : sig type ('a, 'e) t = ('a, 'e) state end
                  module Eval :
                    sig
                      class type ['a, 'r] semantics =
                        ['a, 'r] Eval.T2(M).semantics
                      class type virtual ['a, 'r, 's] domain =
                        ['a, 'r, 's] Eval.T2(M).domain
                      class type virtual ['a, 'r, 's] eff =
                        ['a, 'r, 's] Eval.T2(M).eff
                      class virtual ['a, 'r, 's] t :
                        object
                          method division_by_zero : unit -> ('r, 'a) state
                          method eval_binop :
                            binop -> exp -> exp -> ('r, 'a) M.t
                          method eval_cast :
                            cast -> int -> exp -> ('r, 'a) M.t
                          method eval_concat : exp -> exp -> ('r, 'a) M.t
                          method eval_exp : exp -> ('r, 'a) M.t
                          method eval_extract :
                            int -> int -> exp -> ('r, 'a) M.t
                          method eval_int : word -> ('r, 'a) M.t
                          method eval_ite :
                            cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                          method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                          method eval_load :
                            mem:exp ->
                            addr:exp -> endian -> size -> ('r, 'a) M.t
                          method eval_store :
                            mem:exp ->
                            addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                          method eval_unknown :
                            Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                          method eval_unop : unop -> exp -> ('r, 'a) M.t
                          method eval_var : var -> ('r, 'a) M.t
                          method virtual load : '-> addr -> ('r, 'a) M.t
                          method virtual lookup : var -> ('r, 'a) M.t
                          method private virtual storage_of_value :
                            '-> ('s option, 'a) M.t
                          method virtual store :
                            '-> addr -> word -> ('r, 'a) M.t
                          method type_error : type_error -> ('r, 'a) state
                          method private virtual undefined : ('r, 'a) M.t
                          method virtual update : var -> '-> (unit, 'a) M.t
                          method private virtual value_of_word :
                            word -> ('r, 'a) M.t
                          method private virtual word_of_value :
                            '-> (word option, 'a) M.t
                        end
                    end
                  class ['a] t :
                    object
                      constraint 'a = #Expi.context
                      method division_by_zero : unit -> 'a r
                      method empty : Bil.storage
                      method eval_binop :
                        binop -> exp -> exp -> (Bil.result, 'a) M.t
                      method eval_cast :
                        cast -> int -> exp -> (Bil.result, 'a) M.t
                      method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                      method eval_exp : exp -> (Bil.result, 'a) M.t
                      method eval_extract :
                        int -> int -> exp -> (Bil.result, 'a) M.t
                      method eval_int : word -> (Bil.result, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                      method eval_let :
                        var -> exp -> exp -> (Bil.result, 'a) M.t
                      method eval_load :
                        mem:exp ->
                        addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp ->
                        exp -> endian -> size -> (Bil.result, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                      method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                      method eval_var : var -> (Bil.result, 'a) M.t
                      method load : Bil.storage -> addr -> 'a r
                      method lookup : var -> 'a r
                      method store : Bil.storage -> addr -> word -> 'a r
                      method type_error : type_error -> 'a r
                      method undefined_addr : addr -> 'a r
                      method undefined_var : var -> 'a r
                      method update : var -> Bil.result -> 'a u
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Bap.Std.Bili.context
                  method division_by_zero : unit -> 'Expi.r
                  method empty : Bil.storage
                  method eval : Bap.Std.stmt list -> 'Bap.Std.Bili.S.u
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cpuexn : int -> 'Bap.Std.Bili.S.u
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_if :
                    cond:Bap.Std.exp ->
                    yes:Bap.Std.stmt list ->
                    no:Bap.Std.stmt list -> 'Bap.Std.Bili.S.u
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_jmp : Bap.Std.exp -> 'Bap.Std.Bili.S.u
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_move :
                    Bap.Std.var -> Bap.Std.exp -> 'Bap.Std.Bili.S.u
                  method eval_special : string -> 'Bap.Std.Bili.S.u
                  method eval_stmt : Bap.Std.stmt -> 'Bap.Std.Bili.S.u
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method eval_while :
                    cond:Bap.Std.exp ->
                    body:Bap.Std.stmt list -> 'Bap.Std.Bili.S.u
                  method load : Bil.storage -> addr -> 'Expi.r
                  method lookup : var -> 'Expi.r
                  method store : Bil.storage -> addr -> word -> 'Expi.r
                  method type_error : type_error -> 'Expi.r
                  method undefined_addr : addr -> 'Expi.r
                  method undefined_var : var -> 'Expi.r
                  method update : var -> Bil.result -> 'Expi.u
                end
            end
          module Make :
            functor (M : Monads.Std.Monad.State.S2->
              sig
                type ('a, 'e) state = ('a, 'e) M.t
                type 'a u = (unit, 'a) state
                type 'a r = (Bil.result, 'a) state
                module Expi :
                  sig
                    type ('a, 'e) state = ('a, 'e) M.t
                    type 'a u = (unit, 'a) state
                    type 'a r = (Bil.result, 'a) state
                    module M : sig type ('a, 'e) t = ('a, 'e) state end
                    module Eval :
                      sig
                        class type ['a, 'r] semantics =
                          ['a, 'r] Eval.T2(M).semantics
                        class type virtual ['a, 'r, 's] domain =
                          ['a, 'r, 's] Eval.T2(M).domain
                        class type virtual ['a, 'r, 's] eff =
                          ['a, 'r, 's] Eval.T2(M).eff
                        class virtual ['a, 'r, 's] t :
                          object
                            method division_by_zero : unit -> ('r, 'a) state
                            method eval_binop :
                              binop -> exp -> exp -> ('r, 'a) M.t
                            method eval_cast :
                              cast -> int -> exp -> ('r, 'a) M.t
                            method eval_concat : exp -> exp -> ('r, 'a) M.t
                            method eval_exp : exp -> ('r, 'a) M.t
                            method eval_extract :
                              int -> int -> exp -> ('r, 'a) M.t
                            method eval_int : word -> ('r, 'a) M.t
                            method eval_ite :
                              cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                            method eval_let :
                              var -> exp -> exp -> ('r, 'a) M.t
                            method eval_load :
                              mem:exp ->
                              addr:exp -> endian -> size -> ('r, 'a) M.t
                            method eval_store :
                              mem:exp ->
                              addr:exp ->
                              exp -> endian -> size -> ('r, 'a) M.t
                            method eval_unknown :
                              Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                            method eval_unop : unop -> exp -> ('r, 'a) M.t
                            method eval_var : var -> ('r, 'a) M.t
                            method virtual load : '-> addr -> ('r, 'a) M.t
                            method virtual lookup : var -> ('r, 'a) M.t
                            method private virtual storage_of_value :
                              '-> ('s option, 'a) M.t
                            method virtual store :
                              '-> addr -> word -> ('r, 'a) M.t
                            method type_error : type_error -> ('r, 'a) state
                            method private virtual undefined : ('r, 'a) M.t
                            method virtual update :
                              var -> '-> (unit, 'a) M.t
                            method private virtual value_of_word :
                              word -> ('r, 'a) M.t
                            method private virtual word_of_value :
                              '-> (word option, 'a) M.t
                          end
                      end
                    class ['a] t :
                      object
                        constraint 'a = #Expi.context
                        method division_by_zero : unit -> 'a r
                        method empty : Bil.storage
                        method eval_binop :
                          binop -> exp -> exp -> (Bil.result, 'a) M.t
                        method eval_cast :
                          cast -> int -> exp -> (Bil.result, 'a) M.t
                        method eval_concat :
                          exp -> exp -> (Bil.result, 'a) M.t
                        method eval_exp : exp -> (Bil.result, 'a) M.t
                        method eval_extract :
                          int -> int -> exp -> (Bil.result, 'a) M.t
                        method eval_int : word -> (Bil.result, 'a) M.t
                        method eval_ite :
                          cond:exp ->
                          yes:exp -> no:exp -> (Bil.result, 'a) M.t
                        method eval_let :
                          var -> exp -> exp -> (Bil.result, 'a) M.t
                        method eval_load :
                          mem:exp ->
                          addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                        method eval_store :
                          mem:exp ->
                          addr:exp ->
                          exp -> endian -> size -> (Bil.result, 'a) M.t
                        method eval_unknown :
                          Trie.String.Suffix.key ->
                          typ -> (Bil.result, 'a) M.t
                        method eval_unop :
                          unop -> exp -> (Bil.result, 'a) M.t
                        method eval_var : var -> (Bil.result, 'a) M.t
                        method load : Bil.storage -> addr -> 'a r
                        method lookup : var -> 'a r
                        method store : Bil.storage -> addr -> word -> 'a r
                        method type_error : type_error -> 'a r
                        method undefined_addr : addr -> 'a r
                        method undefined_var : var -> 'a r
                        method update : var -> Bil.result -> 'a u
                      end
                  end
                class ['a] t :
                  object
                    constraint 'a = #context
                    method division_by_zero : unit -> 'Expi.r
                    method empty : Bil.storage
                    method eval : stmt list -> 'a u
                    method eval_binop :
                      binop -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_cast :
                      cast -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                    method eval_cpuexn : int -> 'a u
                    method eval_exp : exp -> (Bil.result, 'a) M.t
                    method eval_extract :
                      int -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_if :
                      cond:exp -> yes:stmt list -> no:stmt list -> 'a u
                    method eval_int : word -> (Bil.result, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                    method eval_jmp : exp -> 'a u
                    method eval_let :
                      var -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_load :
                      mem:exp ->
                      addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_move : var -> exp -> 'a u
                    method eval_special : Trie.String.Suffix.key -> 'a u
                    method eval_stmt : stmt -> 'a u
                    method eval_store :
                      mem:exp ->
                      addr:exp ->
                      exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                    method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                    method eval_var : var -> (Bil.result, 'a) M.t
                    method eval_while : cond:exp -> body:stmt list -> 'a u
                    method load : Bil.storage -> addr -> 'Expi.r
                    method lookup : var -> 'Expi.r
                    method store : Bil.storage -> addr -> word -> 'Expi.r
                    method type_error : type_error -> 'Expi.r
                    method undefined_addr : addr -> 'Expi.r
                    method undefined_var : var -> 'Expi.r
                    method update : var -> Bil.result -> 'Expi.u
                  end
              end
          type ('a, 'e) state = ('a, 'e) Expi.state
          type 'a u = (unit, 'a) state
          type 'a r = (Bil.result, 'a) state
          module Expi :
            sig
              type ('a, 'e) state = ('a, 'e) Expi.state
              type 'a u = (unit, 'a) state
              type 'a r = (Bil.result, 'a) state
              module M : sig type ('a, 'e) t = ('a, 'e) state end
              module Eval :
                sig
                  class type ['a, 'r] semantics =
                    ['a, 'r] Eval.T2(M).semantics
                  class type virtual ['a, 'r, 's] domain =
                    ['a, 'r, 's] Eval.T2(M).domain
                  class type virtual ['a, 'r, 's] eff =
                    ['a, 'r, 's] Eval.T2(M).eff
                  class virtual ['a, 'r, 's] t :
                    object
                      method division_by_zero : unit -> ('r, 'a) state
                      method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                      method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                      method eval_concat : exp -> exp -> ('r, 'a) M.t
                      method eval_exp : exp -> ('r, 'a) M.t
                      method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                      method eval_int : word -> ('r, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                      method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                      method eval_load :
                        mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                      method eval_unop : unop -> exp -> ('r, 'a) M.t
                      method eval_var : var -> ('r, 'a) M.t
                      method virtual load : '-> addr -> ('r, 'a) M.t
                      method virtual lookup : var -> ('r, 'a) M.t
                      method private virtual storage_of_value :
                        '-> ('s option, 'a) M.t
                      method virtual store :
                        '-> addr -> word -> ('r, 'a) M.t
                      method type_error : type_error -> ('r, 'a) state
                      method private virtual undefined : ('r, 'a) M.t
                      method virtual update : var -> '-> (unit, 'a) M.t
                      method private virtual value_of_word :
                        word -> ('r, 'a) M.t
                      method private virtual word_of_value :
                        '-> (word option, 'a) M.t
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Expi.context
                  method division_by_zero : unit -> 'a r
                  method empty : Bil.storage
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method load : Bil.storage -> addr -> 'a r
                  method lookup : var -> 'a r
                  method store : Bil.storage -> addr -> word -> 'a r
                  method type_error : type_error -> 'a r
                  method undefined_addr : addr -> 'a r
                  method undefined_var : var -> 'a r
                  method update : var -> Bil.result -> 'a u
                end
            end
          class ['a] t :
            object
              constraint 'a = #context
              method division_by_zero : unit -> 'Expi.r
              method empty : Bil.storage
              method eval : stmt list -> 'a u
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_cpuexn : int -> 'a u
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_if :
                cond:exp -> yes:stmt list -> no:stmt list -> 'a u
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_jmp : exp -> 'a u
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_move : var -> exp -> 'a u
              method eval_special : Trie.String.Suffix.key -> 'a u
              method eval_stmt : stmt -> 'a u
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method eval_while : cond:exp -> body:stmt list -> 'a u
              method load : Bil.storage -> addr -> 'Expi.r
              method lookup : var -> 'Expi.r
              method store : Bil.storage -> addr -> word -> 'Expi.r
              method type_error : type_error -> 'Expi.r
              method undefined_addr : addr -> 'Expi.r
              method undefined_var : var -> 'Expi.r
              method update : var -> Bil.result -> 'Expi.u
            end
        end
      class ['a] bili :
        object
          constraint 'a = #Bap.Std.Bili.context
          method division_by_zero : unit -> 'Bili.Expi.r
          method empty : Bil.storage
          method eval : stmt list -> 'Bili.u
          method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
          method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
          method eval_cpuexn : int -> 'Bili.u
          method eval_exp : exp -> (Bil.result, 'a) M.t
          method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
          method eval_if :
            cond:exp -> yes:stmt list -> no:stmt list -> 'Bili.u
          method eval_int : word -> (Bil.result, 'a) M.t
          method eval_ite :
            cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
          method eval_jmp : exp -> 'Bili.u
          method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_load :
            mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_move : var -> exp -> 'Bili.u
          method eval_special : Trie.String.Suffix.key -> 'Bili.u
          method eval_stmt : stmt -> 'Bili.u
          method eval_store :
            mem:exp ->
            addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_unknown :
            Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
          method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
          method eval_var : var -> (Bil.result, 'a) M.t
          method eval_while : cond:exp -> body:stmt list -> 'Bili.u
          method load : Bil.storage -> addr -> 'Bili.Expi.r
          method lookup : var -> 'Bili.Expi.r
          method store : Bil.storage -> addr -> word -> 'Bili.Expi.r
          method type_error : type_error -> 'Bili.Expi.r
          method undefined_addr : addr -> 'Bili.Expi.r
          method undefined_var : var -> 'Bili.Expi.r
          method update : var -> Bil.result -> 'Bili.Expi.u
        end
      module Eff :
        sig
          type t
          val none : Bap.Std.Eff.t
          val read : Bap.Std.Eff.t
          val load : Bap.Std.Eff.t
          val store : Bap.Std.Eff.t
          val raise : Bap.Std.Eff.t
          val reads : Bap.Std.Eff.t -> bool
          val loads : Bap.Std.Eff.t -> bool
          val stores : Bap.Std.Eff.t -> bool
          val raises : Bap.Std.Eff.t -> bool
          val has_effects : Bap.Std.Eff.t -> bool
          val has_coeffects : Bap.Std.Eff.t -> bool
          val compute : Bap.Std.exp -> Bap.Std.Eff.t
        end
      module Exp :
        sig
          type t = Bap.Std.Bil.exp
          class state :
            object
              val exps_stack : Bap.Std.exp list
              val under_condition : bool
            end
          class ['a] visitor :
            object
              val exps_stack : exp list
              val under_condition : bool
              method enter_binop :
                Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
              method enter_cast :
                Bap.Std.cast -> int -> Bap.Std.Exp.t -> '-> 'a
              method enter_concat :
                Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
              method enter_exp : Bap.Std.Exp.t -> '-> 'a
              method enter_extract :
                hi:int -> lo:int -> Bap.Std.Exp.t -> '-> 'a
              method enter_int : Bap.Std.word -> '-> 'a
              method enter_ite :
                cond:Bap.Std.Exp.t ->
                yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> '-> 'a
              method enter_let :
                Bap.Std.var ->
                exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> '-> 'a
              method enter_load :
                mem:Bap.Std.Exp.t ->
                addr:Bap.Std.Exp.t ->
                Bap.Std.endian -> Bap.Std.size -> '-> 'a
              method enter_store :
                mem:Bap.Std.Exp.t ->
                addr:Bap.Std.Exp.t ->
                exp:Bap.Std.Exp.t ->
                Bap.Std.endian -> Bap.Std.size -> '-> 'a
              method enter_unknown : string -> Bap.Std.typ -> '-> 'a
              method enter_unop : Bap.Std.unop -> Bap.Std.Exp.t -> '-> 'a
              method enter_var : Bap.Std.var -> '-> 'a
              method leave_binop :
                Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
              method leave_cast :
                Bap.Std.cast -> int -> Bap.Std.Exp.t -> '-> 'a
              method leave_concat :
                Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
              method leave_exp : Bap.Std.Exp.t -> '-> 'a
              method leave_extract :
                hi:int -> lo:int -> Bap.Std.Exp.t -> '-> 'a
              method leave_int : Bap.Std.word -> '-> 'a
              method leave_ite :
                cond:Bap.Std.Exp.t ->
                yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> '-> 'a
              method leave_let :
                Bap.Std.var ->
                exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> '-> 'a
              method leave_load :
                mem:Bap.Std.Exp.t ->
                addr:Bap.Std.Exp.t ->
                Bap.Std.endian -> Bap.Std.size -> '-> 'a
              method leave_store :
                mem:Bap.Std.Exp.t ->
                addr:Bap.Std.Exp.t ->
                exp:Bap.Std.Exp.t ->
                Bap.Std.endian -> Bap.Std.size -> '-> 'a
              method leave_unknown : string -> Bap.Std.typ -> '-> 'a
              method leave_unop : Bap.Std.unop -> Bap.Std.Exp.t -> '-> 'a
              method leave_var : Bap.Std.var -> '-> 'a
              method visit_binop :
                Bap.Std.binop -> Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
              method visit_cast :
                Bap.Std.cast -> int -> Bap.Std.Exp.t -> '-> 'a
              method visit_concat :
                Bap.Std.Exp.t -> Bap.Std.Exp.t -> '-> 'a
              method visit_exp : Bap.Std.Exp.t -> '-> 'a
              method visit_extract :
                hi:int -> lo:int -> Bap.Std.Exp.t -> '-> 'a
              method visit_int : Bap.Std.word -> '-> 'a
              method visit_ite :
                cond:Bap.Std.Exp.t ->
                yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> '-> 'a
              method visit_let :
                Bap.Std.var ->
                exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> '-> 'a
              method visit_load :
                mem:Bap.Std.Exp.t ->
                addr:Bap.Std.Exp.t ->
                Bap.Std.endian -> Bap.Std.size -> '-> 'a
              method visit_store :
                mem:Bap.Std.Exp.t ->
                addr:Bap.Std.Exp.t ->
                exp:Bap.Std.Exp.t ->
                Bap.Std.endian -> Bap.Std.size -> '-> 'a
              method visit_unknown : string -> Bap.Std.typ -> '-> 'a
              method visit_unop : Bap.Std.unop -> Bap.Std.Exp.t -> '-> 'a
              method visit_var : Bap.Std.var -> '-> 'a
            end
          class ['a] finder :
            object
              val exps_stack : exp list
              val under_condition : bool
              method enter_binop :
                binop ->
                t ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_cast :
                cast ->
                int ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_concat :
                t ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_exp :
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_extract :
                hi:int ->
                lo:int ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_int :
                word ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_ite :
                cond:t ->
                yes:t ->
                no:t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_let :
                var ->
                exp:t ->
                body:t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_load :
                mem:t ->
                addr:t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_store :
                mem:t ->
                addr:t ->
                exp:t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_unknown :
                Trie.String.Suffix.key ->
                typ ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_unop :
                unop ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_var :
                var ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method find : Bap.Std.Exp.t -> 'a option
              method leave_binop :
                binop ->
                t ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_cast :
                cast ->
                int ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_concat :
                t ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_exp :
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_extract :
                hi:int ->
                lo:int ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_int :
                word ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_ite :
                cond:t ->
                yes:t ->
                no:t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_let :
                var ->
                exp:t ->
                body:t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_load :
                mem:t ->
                addr:t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_store :
                mem:t ->
                addr:t ->
                exp:t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_unknown :
                Trie.String.Suffix.key ->
                typ ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_unop :
                unop ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_var :
                var ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_binop :
                binop ->
                t ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_cast :
                cast ->
                int ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_concat :
                t ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_exp :
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_extract :
                hi:int ->
                lo:int ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_int :
                word ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_ite :
                cond:t ->
                yes:t ->
                no:t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_let :
                var ->
                exp:t ->
                body:t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_load :
                mem:t ->
                addr:t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_store :
                mem:t ->
                addr:t ->
                exp:t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_unknown :
                Trie.String.Suffix.key ->
                typ ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_unop :
                unop ->
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_var :
                var ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
            end
          class mapper :
            object
              val exps_stack : exp list
              val under_condition : bool
              method map_binop :
                Bap.Std.binop ->
                Bap.Std.Exp.t -> Bap.Std.Exp.t -> Bap.Std.Exp.t
              method map_cast :
                Bap.Std.cast -> int -> Bap.Std.Exp.t -> Bap.Std.Exp.t
              method map_concat :
                Bap.Std.Exp.t -> Bap.Std.Exp.t -> Bap.Std.Exp.t
              method map_exp : Bap.Std.Exp.t -> Bap.Std.Exp.t
              method map_extract :
                hi:int -> lo:int -> Bap.Std.Exp.t -> Bap.Std.Exp.t
              method map_int : Bap.Std.word -> Bap.Std.Exp.t
              method map_ite :
                cond:Bap.Std.Exp.t ->
                yes:Bap.Std.Exp.t -> no:Bap.Std.Exp.t -> Bap.Std.Exp.t
              method map_let :
                Bap.Std.var ->
                exp:Bap.Std.Exp.t -> body:Bap.Std.Exp.t -> Bap.Std.Exp.t
              method map_load :
                mem:Bap.Std.Exp.t ->
                addr:Bap.Std.Exp.t ->
                Bap.Std.endian -> Bap.Std.size -> Bap.Std.Exp.t
              method map_store :
                mem:Bap.Std.Exp.t ->
                addr:Bap.Std.Exp.t ->
                exp:Bap.Std.Exp.t ->
                Bap.Std.endian -> Bap.Std.size -> Bap.Std.Exp.t
              method map_sym : Bap.Std.var -> Bap.Std.var
              method map_unknown : string -> Bap.Std.typ -> Bap.Std.Exp.t
              method map_unop :
                Bap.Std.unop -> Bap.Std.Exp.t -> Bap.Std.Exp.t
              method map_var : Bap.Std.var -> Bap.Std.Exp.t
            end
          val fold :
            '#Bap.Std.Exp.visitor -> init:'-> Bap.Std.Exp.t -> 'a
          val iter : unit #Bap.Std.Exp.visitor -> Bap.Std.Exp.t -> unit
          val find : '#Bap.Std.Exp.finder -> Bap.Std.Exp.t -> 'a option
          val map : #Bap.Std.Exp.mapper -> Bap.Std.Exp.t -> Bap.Std.Exp.t
          val exists : unit #Bap.Std.Exp.finder -> Bap.Std.Exp.t -> bool
          val substitute :
            Bap.Std.exp -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.exp
          val normalize : Bap.Std.exp -> Bap.Std.exp
          val simpl :
            ?ignore:Bap.Std.Eff.t list -> Bap.Std.exp -> Bap.Std.exp
          val is_referenced : Bap.Std.var -> Bap.Std.Exp.t -> bool
          val normalize_negatives : Bap.Std.Exp.t -> Bap.Std.Exp.t
          val fold_consts : Bap.Std.Exp.t -> Bap.Std.Exp.t
          val fixpoint :
            (Bap.Std.Exp.t -> Bap.Std.Exp.t) ->
            Bap.Std.Exp.t -> Bap.Std.Exp.t
          val free_vars : Bap.Std.Exp.t -> Bap.Std.Var.Set.t
          val eval : Bap.Std.Exp.t -> Bap.Std.Bil.value
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.Bil.exp
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Type_error.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val pp_adt : Bap.Std.Exp.t Regular.Std.printer
        end
      module Stmt :
        sig
          type t = Bap.Std.Bil.stmt
          class state :
            object
              val in_jmp : bool
              val in_loop : bool
              val in_move : bool
              val preds : Bap.Std.stmt list
              val stmts_stack : Bap.Std.stmt list
              val succs : Bap.Std.stmt list
            end
          class ['a] visitor :
            object
              val exps_stack : exp list
              val in_jmp : bool
              val in_loop : bool
              val in_move : bool
              val preds : stmt list
              val stmts_stack : stmt list
              val succs : stmt list
              val under_condition : bool
              method enter_binop : binop -> Exp.t -> Exp.t -> '-> 'a
              method enter_cast : cast -> int -> Exp.t -> '-> 'a
              method enter_concat : Exp.t -> Exp.t -> '-> 'a
              method enter_cpuexn : int -> '-> 'a
              method enter_exp : Exp.t -> '-> 'a
              method enter_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
              method enter_if :
                cond:Bap.Std.exp ->
                yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> '-> 'a
              method enter_int : word -> '-> 'a
              method enter_ite :
                cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
              method enter_jmp : Bap.Std.exp -> '-> 'a
              method enter_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
              method enter_load :
                mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
              method enter_move : Bap.Std.var -> Bap.Std.exp -> '-> 'a
              method enter_special : string -> '-> 'a
              method enter_stmt : Bap.Std.Stmt.t -> '-> 'a
              method enter_store :
                mem:Exp.t ->
                addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
              method enter_unknown :
                Trie.String.Suffix.key -> typ -> '-> 'a
              method enter_unop : unop -> Exp.t -> '-> 'a
              method enter_var : var -> '-> 'a
              method enter_while :
                cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> '-> 'a
              method leave_binop : binop -> Exp.t -> Exp.t -> '-> 'a
              method leave_cast : cast -> int -> Exp.t -> '-> 'a
              method leave_concat : Exp.t -> Exp.t -> '-> 'a
              method leave_cpuexn : int -> '-> 'a
              method leave_exp : Exp.t -> '-> 'a
              method leave_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
              method leave_if :
                cond:Bap.Std.exp ->
                yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> '-> 'a
              method leave_int : word -> '-> 'a
              method leave_ite :
                cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
              method leave_jmp : Bap.Std.exp -> '-> 'a
              method leave_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
              method leave_load :
                mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
              method leave_move : Bap.Std.var -> Bap.Std.exp -> '-> 'a
              method leave_special : string -> '-> 'a
              method leave_stmt : Bap.Std.Stmt.t -> '-> 'a
              method leave_store :
                mem:Exp.t ->
                addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
              method leave_unknown :
                Trie.String.Suffix.key -> typ -> '-> 'a
              method leave_unop : unop -> Exp.t -> '-> 'a
              method leave_var : var -> '-> 'a
              method leave_while :
                cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> '-> 'a
              method run : Bap.Std.Stmt.t list -> '-> 'a
              method visit_binop : binop -> Exp.t -> Exp.t -> '-> 'a
              method visit_cast : cast -> int -> Exp.t -> '-> 'a
              method visit_concat : Exp.t -> Exp.t -> '-> 'a
              method visit_cpuexn : int -> '-> 'a
              method visit_exp : Exp.t -> '-> 'a
              method visit_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
              method visit_if :
                cond:Bap.Std.exp ->
                yes:Bap.Std.Stmt.t list -> no:Bap.Std.Stmt.t list -> '-> 'a
              method visit_int : word -> '-> 'a
              method visit_ite :
                cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
              method visit_jmp : Bap.Std.exp -> '-> 'a
              method visit_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
              method visit_load :
                mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
              method visit_move : Bap.Std.var -> Bap.Std.exp -> '-> 'a
              method visit_special : string -> '-> 'a
              method visit_stmt : Bap.Std.Stmt.t -> '-> 'a
              method visit_store :
                mem:Exp.t ->
                addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
              method visit_unknown :
                Trie.String.Suffix.key -> typ -> '-> 'a
              method visit_unop : unop -> Exp.t -> '-> 'a
              method visit_var : var -> '-> 'a
              method visit_while :
                cond:Bap.Std.exp -> Bap.Std.Stmt.t list -> '-> 'a
            end
          class ['a] finder :
            object
              val exps_stack : exp list
              val in_jmp : bool
              val in_loop : bool
              val in_move : bool
              val preds : stmt list
              val stmts_stack : stmt list
              val succs : stmt list
              val under_condition : bool
              method enter_binop :
                binop ->
                Exp.t ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_cast :
                cast ->
                int ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_concat :
                Exp.t ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_cpuexn :
                int ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_exp :
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_extract :
                hi:int ->
                lo:int ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_if :
                cond:exp ->
                yes:t list ->
                no:t list ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_int :
                word ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_ite :
                cond:Exp.t ->
                yes:Exp.t ->
                no:Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_jmp :
                exp ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_let :
                var ->
                exp:Exp.t ->
                body:Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_load :
                mem:Exp.t ->
                addr:Exp.t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_move :
                var ->
                exp ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_special :
                Trie.String.Suffix.key ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_stmt :
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_store :
                mem:Exp.t ->
                addr:Exp.t ->
                exp:Exp.t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_unknown :
                Trie.String.Suffix.key ->
                typ ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_unop :
                unop ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_var :
                var ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method enter_while :
                cond:exp ->
                t list ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method find : Bap.Std.Stmt.t list -> 'a option
              method leave_binop :
                binop ->
                Exp.t ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_cast :
                cast ->
                int ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_concat :
                Exp.t ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_cpuexn :
                int ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_exp :
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_extract :
                hi:int ->
                lo:int ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_if :
                cond:exp ->
                yes:t list ->
                no:t list ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_int :
                word ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_ite :
                cond:Exp.t ->
                yes:Exp.t ->
                no:Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_jmp :
                exp ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_let :
                var ->
                exp:Exp.t ->
                body:Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_load :
                mem:Exp.t ->
                addr:Exp.t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_move :
                var ->
                exp ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_special :
                Trie.String.Suffix.key ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_stmt :
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_store :
                mem:Exp.t ->
                addr:Exp.t ->
                exp:Exp.t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_unknown :
                Trie.String.Suffix.key ->
                typ ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_unop :
                unop ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_var :
                var ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method leave_while :
                cond:exp ->
                t list ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method run :
                t list ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_binop :
                binop ->
                Exp.t ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_cast :
                cast ->
                int ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_concat :
                Exp.t ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_cpuexn :
                int ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_exp :
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_extract :
                hi:int ->
                lo:int ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_if :
                cond:exp ->
                yes:t list ->
                no:t list ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_int :
                word ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_ite :
                cond:Exp.t ->
                yes:Exp.t ->
                no:Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_jmp :
                exp ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_let :
                var ->
                exp:Exp.t ->
                body:Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_load :
                mem:Exp.t ->
                addr:Exp.t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_move :
                var ->
                exp ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_special :
                Trie.String.Suffix.key ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_stmt :
                t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_store :
                mem:Exp.t ->
                addr:Exp.t ->
                exp:Exp.t ->
                endian ->
                size ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_unknown :
                Trie.String.Suffix.key ->
                typ ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_unop :
                unop ->
                Exp.t ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_var :
                var ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
              method visit_while :
                cond:exp ->
                t list ->
                'a option Core_kernel.Std.return ->
                'a option Core_kernel.Std.return
            end
          class mapper :
            object
              val exps_stack : exp list
              val in_jmp : bool
              val in_loop : bool
              val in_move : bool
              val preds : stmt list
              val stmts_stack : stmt list
              val succs : stmt list
              val under_condition : bool
              method map_binop : binop -> Exp.t -> Exp.t -> Exp.t
              method map_cast : cast -> int -> Exp.t -> Exp.t
              method map_concat : Exp.t -> Exp.t -> Exp.t
              method map_cpuexn : int -> Bap.Std.Stmt.t list
              method map_exp : Exp.t -> Exp.t
              method map_extract : hi:int -> lo:int -> Exp.t -> Exp.t
              method map_if :
                cond:Bap.Std.exp ->
                yes:Bap.Std.Stmt.t list ->
                no:Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
              method map_int : word -> Exp.t
              method map_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> Exp.t
              method map_jmp : Bap.Std.exp -> Bap.Std.Stmt.t list
              method map_let : var -> exp:Exp.t -> body:Exp.t -> Exp.t
              method map_load :
                mem:Exp.t -> addr:Exp.t -> endian -> size -> Exp.t
              method map_move :
                Bap.Std.var -> Bap.Std.exp -> Bap.Std.Stmt.t list
              method map_special : string -> Bap.Std.Stmt.t list
              method map_stmt : Bap.Std.Stmt.t -> Bap.Std.Stmt.t list
              method map_store :
                mem:Exp.t ->
                addr:Exp.t -> exp:Exp.t -> endian -> size -> Exp.t
              method map_sym : var -> var
              method map_unknown : Trie.String.Suffix.key -> typ -> Exp.t
              method map_unop : unop -> Exp.t -> Exp.t
              method map_var : var -> Exp.t
              method map_while :
                cond:Bap.Std.exp ->
                Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
              method run : Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
            end
          class constant_folder : mapper
          val fold :
            '#Bap.Std.Stmt.visitor -> init:'-> Bap.Std.Stmt.t -> 'a
          val iter : unit #Bap.Std.Stmt.visitor -> Bap.Std.Stmt.t -> unit
          val map :
            #Bap.Std.Stmt.mapper ->
            Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
          val find : '#Bap.Std.Stmt.finder -> Bap.Std.Stmt.t -> 'a option
          val exists : unit #Bap.Std.Stmt.finder -> Bap.Std.Stmt.t -> bool
          val is_referenced : Bap.Std.var -> Bap.Std.Stmt.t -> bool
          val normalize :
            ?normalize_exp:bool -> Bap.Std.stmt list -> Bap.Std.stmt list
          val simpl :
            ?ignore:Bap.Std.Eff.t list ->
            Bap.Std.Stmt.t list -> Bap.Std.Stmt.t list
          val fixpoint :
            (Bap.Std.Stmt.t -> Bap.Std.Stmt.t) ->
            Bap.Std.Stmt.t -> Bap.Std.Stmt.t
          val free_vars : Bap.Std.Stmt.t -> Bap.Std.Var.Set.t
          val eval :
            Bap.Std.Stmt.t list -> (#Bap.Std.Bili.context as 'a) -> 'a
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.Bil.stmt
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Exp.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val pp_adt : Bap.Std.Stmt.t Regular.Std.printer
        end
      module Arch :
        sig
          type x86 = [ `x86 | `x86_64 ]
          val bin_x86 : x86 Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_x86 : x86 Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_x86__ :
            (int -> x86) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_x86 : x86 Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_x86 : x86 Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_x86 : x86 Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_x86 : x86 Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_x86 : Core_kernel.Std.Bin_prot.Shape.t
          val compare_x86 : x86 -> x86 -> int
          val all_of_x86 : x86 list
          val x86_of_sexp : Sexplib.Sexp.t -> x86
          val __x86_of_sexp__ : Sexplib.Sexp.t -> x86
          val sexp_of_x86 : x86 -> Sexplib.Sexp.t
          type arm = [ `armv4 | `armv5 | `armv6 | `armv7 ]
          val bin_arm : arm Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_arm : arm Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_arm__ :
            (int -> arm) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_arm : arm Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_arm : arm Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_arm : arm Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_arm : arm Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_arm : Core_kernel.Std.Bin_prot.Shape.t
          val compare_arm : arm -> arm -> int
          val all_of_arm : arm list
          val arm_of_sexp : Sexplib.Sexp.t -> arm
          val __arm_of_sexp__ : Sexplib.Sexp.t -> arm
          val sexp_of_arm : arm -> Sexplib.Sexp.t
          type armeb = [ `armv4eb | `armv5eb | `armv6eb | `armv7eb ]
          val bin_armeb : armeb Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_armeb : armeb Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_armeb__ :
            (int -> armeb) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_armeb :
            armeb Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_armeb : armeb Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_armeb : armeb Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_armeb :
            armeb Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_armeb : Core_kernel.Std.Bin_prot.Shape.t
          val compare_armeb : armeb -> armeb -> int
          val all_of_armeb : armeb list
          val armeb_of_sexp : Sexplib.Sexp.t -> armeb
          val __armeb_of_sexp__ : Sexplib.Sexp.t -> armeb
          val sexp_of_armeb : armeb -> Sexplib.Sexp.t
          type thumb = [ `thumbv4 | `thumbv5 | `thumbv6 | `thumbv7 ]
          val bin_thumb : thumb Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_thumb : thumb Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_thumb__ :
            (int -> thumb) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_thumb :
            thumb Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_thumb : thumb Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_thumb : thumb Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_thumb :
            thumb Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_thumb : Core_kernel.Std.Bin_prot.Shape.t
          val compare_thumb : thumb -> thumb -> int
          val all_of_thumb : thumb list
          val thumb_of_sexp : Sexplib.Sexp.t -> thumb
          val __thumb_of_sexp__ : Sexplib.Sexp.t -> thumb
          val sexp_of_thumb : thumb -> Sexplib.Sexp.t
          type thumbeb =
              [ `thumbv4eb | `thumbv5eb | `thumbv6eb | `thumbv7eb ]
          val bin_thumbeb : thumbeb Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_thumbeb : thumbeb Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_thumbeb__ :
            (int -> thumbeb) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_thumbeb :
            thumbeb Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_thumbeb : thumbeb Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_thumbeb :
            thumbeb Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_thumbeb :
            thumbeb Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_thumbeb : Core_kernel.Std.Bin_prot.Shape.t
          val compare_thumbeb : thumbeb -> thumbeb -> int
          val all_of_thumbeb : thumbeb list
          val thumbeb_of_sexp : Sexplib.Sexp.t -> thumbeb
          val __thumbeb_of_sexp__ : Sexplib.Sexp.t -> thumbeb
          val sexp_of_thumbeb : thumbeb -> Sexplib.Sexp.t
          type aarch64 = [ `aarch64 | `aarch64_be ]
          val bin_aarch64 : aarch64 Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_aarch64 : aarch64 Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_aarch64__ :
            (int -> aarch64) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_aarch64 :
            aarch64 Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_aarch64 : aarch64 Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_aarch64 :
            aarch64 Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_aarch64 :
            aarch64 Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_aarch64 : Core_kernel.Std.Bin_prot.Shape.t
          val compare_aarch64 : aarch64 -> aarch64 -> int
          val all_of_aarch64 : aarch64 list
          val aarch64_of_sexp : Sexplib.Sexp.t -> aarch64
          val __aarch64_of_sexp__ : Sexplib.Sexp.t -> aarch64
          val sexp_of_aarch64 : aarch64 -> Sexplib.Sexp.t
          type ppc = [ `ppc | `ppc64 | `ppc64le ]
          val bin_ppc : ppc Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_ppc : ppc Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_ppc__ :
            (int -> ppc) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_ppc : ppc Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_ppc : ppc Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_ppc : ppc Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_ppc : ppc Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_ppc : Core_kernel.Std.Bin_prot.Shape.t
          val compare_ppc : ppc -> ppc -> int
          val all_of_ppc : ppc list
          val ppc_of_sexp : Sexplib.Sexp.t -> ppc
          val __ppc_of_sexp__ : Sexplib.Sexp.t -> ppc
          val sexp_of_ppc : ppc -> Sexplib.Sexp.t
          type mips = [ `mips | `mips64 | `mips64el | `mipsel ]
          val bin_mips : mips Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_mips : mips Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_mips__ :
            (int -> mips) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_mips :
            mips Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_mips : mips Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_mips : mips Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_mips :
            mips Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_mips : Core_kernel.Std.Bin_prot.Shape.t
          val compare_mips : mips -> mips -> int
          val all_of_mips : mips list
          val mips_of_sexp : Sexplib.Sexp.t -> mips
          val __mips_of_sexp__ : Sexplib.Sexp.t -> mips
          val sexp_of_mips : mips -> Sexplib.Sexp.t
          type sparc = [ `sparc | `sparcv9 ]
          val bin_sparc : sparc Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_sparc : sparc Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_sparc__ :
            (int -> sparc) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_sparc :
            sparc Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_sparc : sparc Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_sparc : sparc Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_sparc :
            sparc Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_sparc : Core_kernel.Std.Bin_prot.Shape.t
          val compare_sparc : sparc -> sparc -> int
          val all_of_sparc : sparc list
          val sparc_of_sexp : Sexplib.Sexp.t -> sparc
          val __sparc_of_sexp__ : Sexplib.Sexp.t -> sparc
          val sexp_of_sparc : sparc -> Sexplib.Sexp.t
          type nvptx = [ `nvptx | `nvptx64 ]
          val bin_nvptx : nvptx Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_nvptx : nvptx Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_nvptx__ :
            (int -> nvptx) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_nvptx :
            nvptx Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_nvptx : nvptx Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_nvptx : nvptx Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_nvptx :
            nvptx Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_nvptx : Core_kernel.Std.Bin_prot.Shape.t
          val compare_nvptx : nvptx -> nvptx -> int
          val all_of_nvptx : nvptx list
          val nvptx_of_sexp : Sexplib.Sexp.t -> nvptx
          val __nvptx_of_sexp__ : Sexplib.Sexp.t -> nvptx
          val sexp_of_nvptx : nvptx -> Sexplib.Sexp.t
          type hexagon = [ `hexagon ]
          val bin_hexagon : hexagon Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_hexagon : hexagon Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_hexagon__ :
            (int -> hexagon) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_hexagon :
            hexagon Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_hexagon : hexagon Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_hexagon :
            hexagon Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_hexagon :
            hexagon Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_hexagon : Core_kernel.Std.Bin_prot.Shape.t
          val compare_hexagon : hexagon -> hexagon -> int
          val all_of_hexagon : hexagon list
          val hexagon_of_sexp : Sexplib.Sexp.t -> hexagon
          val __hexagon_of_sexp__ : Sexplib.Sexp.t -> hexagon
          val sexp_of_hexagon : hexagon -> Sexplib.Sexp.t
          type r600 = [ `r600 ]
          val bin_r600 : r600 Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_r600 : r600 Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_r600__ :
            (int -> r600) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_r600 :
            r600 Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_r600 : r600 Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_r600 : r600 Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_r600 :
            r600 Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_r600 : Core_kernel.Std.Bin_prot.Shape.t
          val compare_r600 : r600 -> r600 -> int
          val all_of_r600 : r600 list
          val r600_of_sexp : Sexplib.Sexp.t -> r600
          val __r600_of_sexp__ : Sexplib.Sexp.t -> r600
          val sexp_of_r600 : r600 -> Sexplib.Sexp.t
          type systemz = [ `systemz ]
          val bin_systemz : systemz Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_systemz : systemz Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_systemz__ :
            (int -> systemz) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_systemz :
            systemz Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_systemz : systemz Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_systemz :
            systemz Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_systemz :
            systemz Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_systemz : Core_kernel.Std.Bin_prot.Shape.t
          val compare_systemz : systemz -> systemz -> int
          val all_of_systemz : systemz list
          val systemz_of_sexp : Sexplib.Sexp.t -> systemz
          val __systemz_of_sexp__ : Sexplib.Sexp.t -> systemz
          val sexp_of_systemz : systemz -> Sexplib.Sexp.t
          type xcore = [ `xcore ]
          val bin_xcore : xcore Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_xcore : xcore Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_xcore__ :
            (int -> xcore) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_xcore :
            xcore Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_xcore : xcore Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_xcore : xcore Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_xcore :
            xcore Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_xcore : Core_kernel.Std.Bin_prot.Shape.t
          val compare_xcore : xcore -> xcore -> int
          val all_of_xcore : xcore list
          val xcore_of_sexp : Sexplib.Sexp.t -> xcore
          val __xcore_of_sexp__ : Sexplib.Sexp.t -> xcore
          val sexp_of_xcore : xcore -> Sexplib.Sexp.t
          type t =
              [ `aarch64
              | `aarch64_be
              | `armv4
              | `armv4eb
              | `armv5
              | `armv5eb
              | `armv6
              | `armv6eb
              | `armv7
              | `armv7eb
              | `hexagon
              | `mips
              | `mips64
              | `mips64el
              | `mipsel
              | `nvptx
              | `nvptx64
              | `ppc
              | `ppc64
              | `ppc64le
              | `r600
              | `sparc
              | `sparcv9
              | `systemz
              | `thumbv4
              | `thumbv4eb
              | `thumbv5
              | `thumbv5eb
              | `thumbv6
              | `thumbv6eb
              | `thumbv7
              | `thumbv7eb
              | `x86
              | `x86_64
              | `xcore ]
          val all : t list
          val __t_of_sexp__ : Sexplib.Sexp.t -> t
          val of_string : string -> Bap.Std.Arch.t option
          val addr_size : Bap.Std.Arch.t -> Bap.Std.addr_size
          val endian : Bap.Std.Arch.t -> Bap.Std.endian
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Stmt.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      type arch = Bap.Std.Arch.t
      val bin_arch : arch Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_arch : arch Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_arch__ :
        (int -> arch) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_arch : arch Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_arch : arch Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_arch : arch Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_arch : arch Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_arch : Core_kernel.Std.Bin_prot.Shape.t
      val compare_arch : arch -> arch -> int
      val arch_of_sexp : Sexplib.Sexp.t -> arch
      val sexp_of_arch : arch -> Sexplib.Sexp.t
      module Value :
        sig
          type t = Bap.Std.value
          type 'a tag
          module type S =
            sig
              type t
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val compare : t -> t -> int
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val pp : Format.formatter -> Bap.Std.Value.S.t -> unit
            end
          type void
          type literal =
              (Bap.Std.Value.void, Bap.Std.Value.void, Bap.Std.Value.void)
              Core_kernel.Std.format
          type typeid
          val bin_typeid : typeid Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_typeid : typeid Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_typeid__ :
            (int -> typeid) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_typeid :
            typeid Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_typeid : typeid Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_typeid : typeid Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_typeid :
            typeid Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_typeid : Core_kernel.Std.Bin_prot.Shape.t
          val compare_typeid : typeid -> typeid -> int
          val typeid_of_sexp : Sexplib.Sexp.t -> typeid
          val sexp_of_typeid : typeid -> Sexplib.Sexp.t
          val create : 'Bap.Std.Value.tag -> '-> Bap.Std.Value.t
          val is : 'Bap.Std.Value.tag -> Bap.Std.Value.t -> bool
          val get : 'Bap.Std.Value.tag -> Bap.Std.Value.t -> 'a option
          val get_exn : 'Bap.Std.Value.tag -> Bap.Std.Value.t -> 'a
          val tagname : Bap.Std.Value.t -> string
          val typeid : Bap.Std.Value.t -> Bap.Std.Value.typeid
          module Tag :
            sig
              type 'a t = 'Bap.Std.Value.tag
              val register :
                name:Bap.Std.Value.literal ->
                uuid:Bap.Std.Value.literal ->
                (module Bap.Std.Value.S with type t = 'a) ->
                'Bap.Std.Value.tag
              val name : 'Bap.Std.Value.Tag.t -> string
              val same :
                'Bap.Std.Value.Tag.t -> 'Bap.Std.Value.Tag.t -> bool
              val same_witness :
                'Bap.Std.Value.Tag.t ->
                'Bap.Std.Value.Tag.t ->
                ('a, 'b) Core_kernel.Std.Type_equal.t option
              val same_witness_exn :
                'Bap.Std.Value.Tag.t ->
                'Bap.Std.Value.Tag.t ->
                ('a, 'b) Core_kernel.Std.Type_equal.t
              val typeid : 'Bap.Std.Value.Tag.t -> Bap.Std.Value.typeid
            end
          module Match :
            sig
              type 'a t
              val switch : Bap.Std.value -> 'Bap.Std.Value.Match.t -> 's
              val select : 'Bap.Std.Value.Match.t -> Bap.Std.value -> 's
              val case :
                'Bap.Std.Value.tag ->
                ('-> 's) ->
                'Bap.Std.Value.Match.t -> 'Bap.Std.Value.Match.t
              val default : (unit -> 's) -> 'Bap.Std.Value.Match.t
            end
          module Typeid :
            sig
              type t = typeid
              val bin_t : t Bin_prot.Type_class.t
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ :
                (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_shape_t : Bin_prot.Shape.t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val of_string : Trie.String.Suffix.key -> t
              val to_string : t -> Trie.String.Suffix.key
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
              module Map :
                sig
                  module Key :
                    sig
                      type t = typeid
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (typeid, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : typeid -> '-> 'a t
                      val of_alist :
                        (typeid * 'a) list ->
                        [ `Duplicate_key of typeid | `Ok of 'a t ]
                      val of_alist_or_error :
                        (typeid * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (typeid * 'a) list -> 'a t
                      val of_alist_multi : (typeid * 'a) list -> 'a list t
                      val of_alist_fold :
                        (typeid * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (typeid * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (typeid * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (typeid * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> typeid * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:typeid -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of typeid | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (typeid, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        typeid Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:typeid -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:typeid -> data:'-> 'a list t
                      val remove_multi : 'a list t -> typeid -> 'a list t
                      val change :
                        'a t -> typeid -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> typeid -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> typeid -> 'a option
                      val find_exn : 'a t -> typeid -> 'a
                      val remove : 'a t -> typeid -> 'a t
                      val mem : 'a t -> typeid -> bool
                      val iter_keys : 'a t -> f:(typeid -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:typeid -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:typeid ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:typeid -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'->
                        f:(key:typeid -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'->
                        f:(key:typeid -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:typeid ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(typeid -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:typeid -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t ->
                        f:(key:typeid -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:typeid ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:typeid -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> typeid list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (typeid * 'a) list
                      val validate :
                        name:(typeid -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:typeid ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (typeid, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (typeid * 'a) option
                      val min_elt_exn : 'a t -> typeid * 'a
                      val max_elt : 'a t -> (typeid * 'a) option
                      val max_elt_exn : 'a t -> typeid * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:typeid -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:typeid -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:typeid -> data:'-> bool) -> int
                      val split :
                        'a t -> typeid -> 'a t * (typeid * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:typeid Base__.Maybe_bound.t ->
                        upper_bound:typeid Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:typeid ->
                        max:typeid ->
                        init:'->
                        f:(key:typeid -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t ->
                        min:typeid -> max:typeid -> (typeid * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> typeid -> (typeid * 'a) option
                      val nth : 'a t -> int -> (typeid * 'a) option
                      val nth_exn : 'a t -> int -> typeid * 'a
                      val rank : 'a t -> typeid -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:typeid ->
                        ?keys_less_or_equal_to:typeid ->
                        'a t -> (typeid * 'a) Base__.Sequence.t
                      val obs :
                        typeid Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        typeid Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> typeid
                               end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (typeid, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : typeid -> '-> 'a t
                  val of_alist :
                    (typeid * 'a) list ->
                    [ `Duplicate_key of typeid | `Ok of 'a t ]
                  val of_alist_or_error :
                    (typeid * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (typeid * 'a) list -> 'a t
                  val of_alist_multi : (typeid * 'a) list -> 'a list t
                  val of_alist_fold :
                    (typeid * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (typeid * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (typeid * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (typeid * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> typeid * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:typeid -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of typeid | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (typeid, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    typeid Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:typeid -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:typeid -> data:'-> 'a list t
                  val remove_multi : 'a list t -> typeid -> 'a list t
                  val change :
                    'a t -> typeid -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> typeid -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> typeid -> 'a option
                  val find_exn : 'a t -> typeid -> 'a
                  val remove : 'a t -> typeid -> 'a t
                  val mem : 'a t -> typeid -> bool
                  val iter_keys : 'a t -> f:(typeid -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:typeid -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:typeid ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:typeid -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:typeid ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(typeid -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:typeid -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:typeid -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:typeid -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:typeid -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> typeid list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (typeid * 'a) list
                  val validate :
                    name:(typeid -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:typeid ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (typeid, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (typeid * 'a) option
                  val min_elt_exn : 'a t -> typeid * 'a
                  val max_elt : 'a t -> (typeid * 'a) option
                  val max_elt_exn : 'a t -> typeid * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:typeid -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:typeid -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:typeid -> data:'-> bool) -> int
                  val split :
                    'a t -> typeid -> 'a t * (typeid * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:typeid Base__.Maybe_bound.t ->
                    upper_bound:typeid Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:typeid ->
                    max:typeid ->
                    init:'-> f:(key:typeid -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:typeid -> max:typeid -> (typeid * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> typeid -> (typeid * 'a) option
                  val nth : 'a t -> int -> (typeid * 'a) option
                  val nth_exn : 'a t -> int -> typeid * 'a
                  val rank : 'a t -> typeid -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:typeid ->
                    ?keys_less_or_equal_to:typeid ->
                    'a t -> (typeid * 'a) Base__.Sequence.t
                  val obs :
                    typeid Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    typeid Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> typeid end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : typeid Bin_prot.Type_class.t
                               val bin_read_t : typeid Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> typeid)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 typeid Bin_prot.Type_class.reader
                               val bin_size_t : typeid Bin_prot.Size.sizer
                               val bin_write_t : typeid Bin_prot.Write.writer
                               val bin_writer_t :
                                 typeid Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 typeid -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = typeid
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (typeid, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(typeid -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> typeid -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> typeid -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(typeid -> bool) -> bool
                      val for_all : t -> f:(typeid -> bool) -> bool
                      val count : t -> f:(typeid -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(typeid -> 'sum) -> 'sum
                      val find : t -> f:(typeid -> bool) -> typeid option
                      val find_map :
                        t -> f:(typeid -> 'a option) -> 'a option
                      val to_list : t -> typeid list
                      val to_array : t -> typeid array
                      val invariants : t -> bool
                      val mem : t -> typeid -> bool
                      val add : t -> typeid -> t
                      val remove : t -> typeid -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t ->
                        (typeid, typeid) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           typeid ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(typeid -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of typeid * typeid
                           | `Left of typeid
                           | `Right of typeid ] -> unit) ->
                        unit
                      val filter : t -> f:(typeid -> bool) -> t
                      val partition_tf : t -> f:(typeid -> bool) -> t * t
                      val elements : t -> typeid list
                      val min_elt : t -> typeid option
                      val min_elt_exn : t -> typeid
                      val max_elt : t -> typeid option
                      val max_elt_exn : t -> typeid
                      val choose : t -> typeid option
                      val choose_exn : t -> typeid
                      val split : t -> typeid -> t * typeid option * t
                      val group_by :
                        t -> equiv:(typeid -> typeid -> bool) -> t list
                      val find_exn : t -> f:(typeid -> bool) -> typeid
                      val find_index : t -> int -> typeid option
                      val nth : t -> int -> typeid option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:typeid ->
                        ?less_or_equal_to:typeid ->
                        t -> typeid Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:typeid ->
                        ?less_or_equal_to:typeid ->
                        t ->
                        t ->
                        (typeid, typeid)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(typeid -> 'data) ->
                        (typeid, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        typeid Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        typeid Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : typeid -> t
                      val union_list : t list -> t
                      val of_list : typeid list -> t
                      val of_array : typeid array -> t
                      val of_sorted_array :
                        typeid array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : typeid array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> typeid) -> t
                      val stable_dedup_list : typeid list -> typeid list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> typeid) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> typeid option) -> t
                      val of_tree : t -> t
                      val of_hash_set : typeid Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (typeid, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (typeid, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        typeid Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> typeid
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (typeid, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(typeid -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> typeid -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> typeid -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(typeid -> bool) -> bool
                  val for_all : t -> f:(typeid -> bool) -> bool
                  val count : t -> f:(typeid -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(typeid -> 'sum) -> 'sum
                  val find : t -> f:(typeid -> bool) -> typeid option
                  val find_map : t -> f:(typeid -> 'a option) -> 'a option
                  val to_list : t -> typeid list
                  val to_array : t -> typeid array
                  val invariants : t -> bool
                  val mem : t -> typeid -> bool
                  val add : t -> typeid -> t
                  val remove : t -> typeid -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (typeid, typeid) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       typeid ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(typeid -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of typeid * typeid
                       | `Left of typeid
                       | `Right of typeid ] -> unit) ->
                    unit
                  val filter : t -> f:(typeid -> bool) -> t
                  val partition_tf : t -> f:(typeid -> bool) -> t * t
                  val elements : t -> typeid list
                  val min_elt : t -> typeid option
                  val min_elt_exn : t -> typeid
                  val max_elt : t -> typeid option
                  val max_elt_exn : t -> typeid
                  val choose : t -> typeid option
                  val choose_exn : t -> typeid
                  val split : t -> typeid -> t * typeid option * t
                  val group_by :
                    t -> equiv:(typeid -> typeid -> bool) -> t list
                  val find_exn : t -> f:(typeid -> bool) -> typeid
                  val find_index : t -> int -> typeid option
                  val nth : t -> int -> typeid option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:typeid ->
                    ?less_or_equal_to:typeid -> t -> typeid Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:typeid ->
                    ?less_or_equal_to:typeid ->
                    t ->
                    t ->
                    (typeid, typeid)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(typeid -> 'data) ->
                    (typeid, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    typeid Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    typeid Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : typeid -> t
                  val union_list : t list -> t
                  val of_list : typeid list -> t
                  val of_array : typeid array -> t
                  val of_sorted_array : typeid array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : typeid array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> typeid) -> t
                  val stable_dedup_list : typeid list -> typeid list
                  val map : ('a, 'b) Base.Set.t -> f:('-> typeid) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> typeid option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : typeid Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (typeid, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (typeid, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    typeid Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> typeid end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : typeid Bin_prot.Type_class.t
                               val bin_read_t : typeid Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> typeid)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 typeid Bin_prot.Type_class.reader
                               val bin_size_t : typeid Bin_prot.Size.sizer
                               val bin_write_t : typeid Bin_prot.Write.writer
                               val bin_writer_t :
                                 typeid Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 typeid -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              val hash : t -> Core_kernel__.Import.int
              val hashable : t Core_kernel__.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl =
                      ('a, 'b) Core_kernel__.Hashable.Hashtbl.t
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = typeid
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> typeid -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> typeid -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> typeid -> 'a
                  val enqueue :
                    'a t -> typeid -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> typeid -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> typeid -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> typeid -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (typeid * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> typeid Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (typeid * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> typeid * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> typeid -> [ `No_such_key | `Ok ]
                  val remove_exn :
                    'a t -> typeid -> Core_kernel__.Import.unit
                  val replace :
                    'a t -> typeid -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> typeid -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:typeid -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:typeid -> data:'-> 'b) -> 'b
                end
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
            end
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.value
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Arch.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      type 'a tag = 'Bap.Std.Value.tag
      module Dict :
        sig
          type t = Bap.Std.dict
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val compare : t -> t -> int
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val empty : Bap.Std.Dict.t
          val is_empty : Bap.Std.Dict.t -> bool
          val set : Bap.Std.Dict.t -> 'Bap.Std.tag -> '-> Bap.Std.Dict.t
          val mem : Bap.Std.Dict.t -> 'Bap.Std.tag -> bool
          val find : Bap.Std.Dict.t -> 'Bap.Std.tag -> 'a option
          val add :
            Bap.Std.Dict.t ->
            'Bap.Std.tag -> '-> [ `Duplicate | `Ok of Bap.Std.Dict.t ]
          val change :
            Bap.Std.Dict.t ->
            'Bap.Std.tag -> ('a option -> 'a option) -> Bap.Std.Dict.t
          val remove : Bap.Std.Dict.t -> 'Bap.Std.tag -> Bap.Std.Dict.t
          val to_sequence :
            Bap.Std.Dict.t ->
            (Bap.Std.Value.typeid * Bap.Std.value) Bap.Std.seq
          val data : Bap.Std.Dict.t -> Bap.Std.value Bap.Std.seq
          val filter :
            Bap.Std.Dict.t -> f:(Bap.Std.value -> bool) -> Bap.Std.Dict.t
        end
      type 'a vector
      module Vector :
        sig
          type 'a t = 'Bap.Std.vector
          val bin_t :
            'Core_kernel.Std.Bin_prot.Type_class.t ->
            'a t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t :
            'Core_kernel.Std.Bin_prot.Read.reader ->
            'a t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            'Core_kernel.Std.Bin_prot.Read.reader ->
            (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t :
            'Core_kernel.Std.Bin_prot.Type_class.reader ->
            'a t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t :
            'Core_kernel.Std.Bin_prot.Size.sizer ->
            'a t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t :
            'Core_kernel.Std.Bin_prot.Write.writer ->
            'a t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t :
            'Core_kernel.Std.Bin_prot.Type_class.writer ->
            'a t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t :
            Core_kernel.Std.Bin_prot.Shape.t ->
            Core_kernel.Std.Bin_prot.Shape.t
          val compare : ('-> '-> int) -> 'a t -> 'a t -> int
          val t_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
          val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val create : ?capacity:int -> '-> 'Bap.Std.Vector.t
          val append : 'Bap.Std.Vector.t -> '-> unit
          val nth : 'Bap.Std.Vector.t -> int -> 'a option
          val get : 'Bap.Std.Vector.t -> int -> 'a
          val set : 'Bap.Std.Vector.t -> int -> '-> unit
          val map_to_array : 'Bap.Std.Vector.t -> f:('-> 'b) -> 'b array
          val findi :
            'Bap.Std.Vector.t -> f:(int -> '-> bool) -> (int * 'a) option
          val iteri : 'Bap.Std.Vector.t -> f:(int -> '-> unit) -> unit
          val foldi :
            'Bap.Std.Vector.t -> init:'-> f:(int -> '-> '-> 'b) -> 'b
          val index :
            ?equal:('-> '-> bool) ->
            'Bap.Std.Vector.t -> '-> int option
          val index_exn :
            ?equal:('-> '-> bool) -> 'Bap.Std.Vector.t -> '-> int
          val index_with :
            ?equal:('-> '-> bool) ->
            default:int -> 'Bap.Std.Vector.t -> '-> int
          val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '-> ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
            ('accum, 'stop) Base.Container_intf.Finished_or_stopped_early.t
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
          val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
          val pp :
            'Regular.Std.printer -> 'Bap.Std.Vector.t Regular.Std.printer
        end
      type 'a term
      val bin_term :
        'Core_kernel.Std.Bin_prot.Type_class.t ->
        'a term Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_term :
        'Core_kernel.Std.Bin_prot.Read.reader ->
        'a term Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_term__ :
        'Core_kernel.Std.Bin_prot.Read.reader ->
        (int -> 'a term) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_term :
        'Core_kernel.Std.Bin_prot.Type_class.reader ->
        'a term Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_term :
        'Core_kernel.Std.Bin_prot.Size.sizer ->
        'a term Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_term :
        'Core_kernel.Std.Bin_prot.Write.writer ->
        'a term Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_term :
        'Core_kernel.Std.Bin_prot.Type_class.writer ->
        'a term Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_term :
        Core_kernel.Std.Bin_prot.Shape.t -> Core_kernel.Std.Bin_prot.Shape.t
      val compare_term : ('-> '-> int) -> 'a term -> 'a term -> int
      val term_of_sexp : (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a term
      val sexp_of_term : ('-> Sexplib.Sexp.t) -> 'a term -> Sexplib.Sexp.t
      type program
      val bin_program : program Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_program : program Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_program__ :
        (int -> program) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_program :
        program Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_program : program Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_program : program Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_program :
        program Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_program : Core_kernel.Std.Bin_prot.Shape.t
      val compare_program : program -> program -> int
      val program_of_sexp : Sexplib.Sexp.t -> program
      val sexp_of_program : program -> Sexplib.Sexp.t
      type sub
      val bin_sub : sub Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_sub : sub Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_sub__ :
        (int -> sub) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_sub : sub Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_sub : sub Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_sub : sub Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_sub : sub Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_sub : Core_kernel.Std.Bin_prot.Shape.t
      val compare_sub : sub -> sub -> int
      val sub_of_sexp : Sexplib.Sexp.t -> sub
      val sexp_of_sub : sub -> Sexplib.Sexp.t
      type arg
      val bin_arg : arg Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_arg : arg Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_arg__ :
        (int -> arg) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_arg : arg Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_arg : arg Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_arg : arg Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_arg : arg Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_arg : Core_kernel.Std.Bin_prot.Shape.t
      val compare_arg : arg -> arg -> int
      val arg_of_sexp : Sexplib.Sexp.t -> arg
      val sexp_of_arg : arg -> Sexplib.Sexp.t
      type blk
      val bin_blk : blk Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_blk : blk Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_blk__ :
        (int -> blk) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_blk : blk Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_blk : blk Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_blk : blk Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_blk : blk Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_blk : Core_kernel.Std.Bin_prot.Shape.t
      val compare_blk : blk -> blk -> int
      val blk_of_sexp : Sexplib.Sexp.t -> blk
      val sexp_of_blk : blk -> Sexplib.Sexp.t
      type phi
      val bin_phi : phi Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_phi : phi Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_phi__ :
        (int -> phi) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_phi : phi Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_phi : phi Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_phi : phi Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_phi : phi Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_phi : Core_kernel.Std.Bin_prot.Shape.t
      val compare_phi : phi -> phi -> int
      val phi_of_sexp : Sexplib.Sexp.t -> phi
      val sexp_of_phi : phi -> Sexplib.Sexp.t
      type def
      val bin_def : def Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_def : def Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_def__ :
        (int -> def) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_def : def Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_def : def Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_def : def Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_def : def Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_def : Core_kernel.Std.Bin_prot.Shape.t
      val compare_def : def -> def -> int
      val def_of_sexp : Sexplib.Sexp.t -> def
      val sexp_of_def : def -> Sexplib.Sexp.t
      type jmp
      val bin_jmp : jmp Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_jmp : jmp Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_jmp__ :
        (int -> jmp) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_jmp : jmp Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_jmp : jmp Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_jmp : jmp Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_jmp : jmp Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_jmp : Core_kernel.Std.Bin_prot.Shape.t
      val compare_jmp : jmp -> jmp -> int
      val jmp_of_sexp : Sexplib.Sexp.t -> jmp
      val sexp_of_jmp : jmp -> Sexplib.Sexp.t
      type nil
      val bin_nil : nil Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_nil : nil Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_nil__ :
        (int -> nil) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_nil : nil Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_nil : nil Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_nil : nil Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_nil : nil Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_nil : Core_kernel.Std.Bin_prot.Shape.t
      val compare_nil : nil -> nil -> int
      val nil_of_sexp : Sexplib.Sexp.t -> nil
      val sexp_of_nil : nil -> Sexplib.Sexp.t
      type tid
      val bin_tid : tid Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_tid : tid Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_tid__ :
        (int -> tid) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_tid : tid Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_tid : tid Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_tid : tid Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_tid : tid Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_tid : Core_kernel.Std.Bin_prot.Shape.t
      val compare_tid : tid -> tid -> int
      val tid_of_sexp : Sexplib.Sexp.t -> tid
      val sexp_of_tid : tid -> Sexplib.Sexp.t
      type call
      val bin_call : call Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_call : call Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_call__ :
        (int -> call) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_call : call Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_call : call Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_call : call Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_call : call Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_call : Core_kernel.Std.Bin_prot.Shape.t
      val compare_call : call -> call -> int
      val call_of_sexp : Sexplib.Sexp.t -> call
      val sexp_of_call : call -> Sexplib.Sexp.t
      type label = Direct of Bap.Std.tid | Indirect of Bap.Std.exp
      val bin_label : label Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_label : label Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_label__ :
        (int -> label) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_label : label Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_label : label Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_label : label Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_label : label Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_label : Core_kernel.Std.Bin_prot.Shape.t
      val compare_label : label -> label -> int
      val label_of_sexp : Sexplib.Sexp.t -> label
      val sexp_of_label : label -> Sexplib.Sexp.t
      type jmp_kind =
          Call of Bap.Std.call
        | Goto of Bap.Std.label
        | Ret of Bap.Std.label
        | Int of int * Bap.Std.tid
      val bin_jmp_kind : jmp_kind Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_jmp_kind : jmp_kind Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_jmp_kind__ :
        (int -> jmp_kind) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_jmp_kind :
        jmp_kind Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_jmp_kind : jmp_kind Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_jmp_kind : jmp_kind Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_jmp_kind :
        jmp_kind Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_jmp_kind : Core_kernel.Std.Bin_prot.Shape.t
      val compare_jmp_kind : jmp_kind -> jmp_kind -> int
      val jmp_kind_of_sexp : Sexplib.Sexp.t -> jmp_kind
      val sexp_of_jmp_kind : jmp_kind -> Sexplib.Sexp.t
      type intent = In | Out | Both
      val bin_intent : intent Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_intent : intent Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_intent__ :
        (int -> intent) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_intent :
        intent Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_intent : intent Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_intent : intent Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_intent :
        intent Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_intent : Core_kernel.Std.Bin_prot.Shape.t
      val compare_intent : intent -> intent -> int
      val intent_of_sexp : Sexplib.Sexp.t -> intent
      val sexp_of_intent : intent -> Sexplib.Sexp.t
      type ('a, 'b) cls
      val program_t : (Bap.Std.nil, Bap.Std.program) Bap.Std.cls
      val sub_t : (Bap.Std.program, Bap.Std.sub) Bap.Std.cls
      val arg_t : (Bap.Std.sub, Bap.Std.arg) Bap.Std.cls
      val blk_t : (Bap.Std.sub, Bap.Std.blk) Bap.Std.cls
      val phi_t : (Bap.Std.blk, Bap.Std.phi) Bap.Std.cls
      val def_t : (Bap.Std.blk, Bap.Std.def) Bap.Std.cls
      val jmp_t : (Bap.Std.blk, Bap.Std.jmp) Bap.Std.cls
      module Biri :
        sig
          class context :
            ?main:Bap.Std.sub Bap.Std.term ->
            Bap.Std.program Bap.Std.term ->
            object ('a)
              method bindings :
                (Bap.Std.var * Bap.Std.Bil.result) Bap.Std.seq
              method create_storage :
                Bap.Std.Bil.storage -> 'a * Bap.Std.Bil.result
              method create_undefined : 'a * Bap.Std.Bil.result
              method create_word : Bap.Std.word -> 'a * Bap.Std.Bil.result
              method enter_term : Bap.Std.tid -> 'a
              method lookup : Bap.Std.var -> Bap.Std.Bil.result option
              method main : Bap.Std.sub Bap.Std.term option
              method next : Bap.Std.tid option
              method program : Bap.Std.program Bap.Std.term
              method set_next : Bap.Std.tid option -> 'a
              method trace : Bap.Std.tid list
              method update : Bap.Std.var -> Bap.Std.Bil.result -> 'a
            end
          module type S =
            sig
              type ('a, 'e) state
              type 'a u = (unit, 'a) Bap.Std.Biri.S.state
              type 'a r = (Bap.Std.Bil.result, 'a) Bap.Std.Biri.S.state
              module Expi :
                sig
                  type ('a, 'e) state = ('a, 'e) state
                  type 'a u = (unit, 'a) state
                  type 'a r = (Bil.result, 'a) state
                  module M : sig type ('a, 'e) t = ('a, 'e) state end
                  module Eval :
                    sig
                      class type ['a, 'r] semantics =
                        ['a, 'r] Eval.T2(M).semantics
                      class type virtual ['a, 'r, 's] domain =
                        ['a, 'r, 's] Eval.T2(M).domain
                      class type virtual ['a, 'r, 's] eff =
                        ['a, 'r, 's] Eval.T2(M).eff
                      class virtual ['a, 'r, 's] t :
                        object
                          method division_by_zero : unit -> ('r, 'a) state
                          method eval_binop :
                            binop -> exp -> exp -> ('r, 'a) M.t
                          method eval_cast :
                            cast -> int -> exp -> ('r, 'a) M.t
                          method eval_concat : exp -> exp -> ('r, 'a) M.t
                          method eval_exp : exp -> ('r, 'a) M.t
                          method eval_extract :
                            int -> int -> exp -> ('r, 'a) M.t
                          method eval_int : word -> ('r, 'a) M.t
                          method eval_ite :
                            cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                          method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                          method eval_load :
                            mem:exp ->
                            addr:exp -> endian -> size -> ('r, 'a) M.t
                          method eval_store :
                            mem:exp ->
                            addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                          method eval_unknown :
                            Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                          method eval_unop : unop -> exp -> ('r, 'a) M.t
                          method eval_var : var -> ('r, 'a) M.t
                          method virtual load : '-> addr -> ('r, 'a) M.t
                          method virtual lookup : var -> ('r, 'a) M.t
                          method private virtual storage_of_value :
                            '-> ('s option, 'a) M.t
                          method virtual store :
                            '-> addr -> word -> ('r, 'a) M.t
                          method type_error : type_error -> ('r, 'a) state
                          method private virtual undefined : ('r, 'a) M.t
                          method virtual update : var -> '-> (unit, 'a) M.t
                          method private virtual value_of_word :
                            word -> ('r, 'a) M.t
                          method private virtual word_of_value :
                            '-> (word option, 'a) M.t
                        end
                    end
                  class ['a] t :
                    object
                      constraint 'a = #Expi.context
                      method division_by_zero : unit -> 'a r
                      method empty : Bil.storage
                      method eval_binop :
                        binop -> exp -> exp -> (Bil.result, 'a) M.t
                      method eval_cast :
                        cast -> int -> exp -> (Bil.result, 'a) M.t
                      method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                      method eval_exp : exp -> (Bil.result, 'a) M.t
                      method eval_extract :
                        int -> int -> exp -> (Bil.result, 'a) M.t
                      method eval_int : word -> (Bil.result, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                      method eval_let :
                        var -> exp -> exp -> (Bil.result, 'a) M.t
                      method eval_load :
                        mem:exp ->
                        addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp ->
                        exp -> endian -> size -> (Bil.result, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                      method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                      method eval_var : var -> (Bil.result, 'a) M.t
                      method load : Bil.storage -> addr -> 'a r
                      method lookup : var -> 'a r
                      method store : Bil.storage -> addr -> word -> 'a r
                      method type_error : type_error -> 'a r
                      method undefined_addr : addr -> 'a r
                      method undefined_var : var -> 'a r
                      method update : var -> Bil.result -> 'a u
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Bap.Std.Biri.context
                  method division_by_zero : unit -> 'Expi.r
                  method empty : Bil.storage
                  method enter_term :
                    ('p, 't) Bap.Std.cls ->
                    'Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method eval :
                    ('p, 't) Bap.Std.cls ->
                    'Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method eval_arg :
                    Bap.Std.arg Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_blk :
                    Bap.Std.blk Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method eval_call : Bap.Std.call -> 'Bap.Std.Biri.S.u
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_def :
                    Bap.Std.def Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method eval_direct : Bap.Std.tid -> 'Bap.Std.Biri.S.u
                  method eval_exn : int -> Bap.Std.tid -> 'Bap.Std.Biri.S.u
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_goto : Bap.Std.label -> 'Bap.Std.Biri.S.u
                  method eval_indirect : Bap.Std.exp -> 'Bap.Std.Biri.S.u
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_jmp :
                    Bap.Std.jmp Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_phi :
                    Bap.Std.phi Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method eval_ret : Bap.Std.label -> 'Bap.Std.Biri.S.u
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_sub :
                    Bap.Std.sub Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method leave_term :
                    ('p, 't) Bap.Std.cls ->
                    'Bap.Std.term -> 'Bap.Std.Biri.S.u
                  method load : Bil.storage -> addr -> 'Expi.r
                  method lookup : var -> 'Expi.r
                  method store : Bil.storage -> addr -> word -> 'Expi.r
                  method type_error : type_error -> 'Expi.r
                  method undefined_addr : addr -> 'Expi.r
                  method undefined_var : var -> 'Expi.r
                  method update : var -> Bil.result -> 'Expi.u
                end
            end
          module Make :
            functor (M : Monads.Std.Monad.State.S2->
              sig
                type ('a, 'e) state = ('a, 'e) M.t
                type 'a u = (unit, 'a) state
                type 'a r = (Bil.result, 'a) state
                module Expi :
                  sig
                    type ('a, 'e) state = ('a, 'e) M.t
                    type 'a u = (unit, 'a) state
                    type 'a r = (Bil.result, 'a) state
                    module M : sig type ('a, 'e) t = ('a, 'e) state end
                    module Eval :
                      sig
                        class type ['a, 'r] semantics =
                          ['a, 'r] Eval.T2(M).semantics
                        class type virtual ['a, 'r, 's] domain =
                          ['a, 'r, 's] Eval.T2(M).domain
                        class type virtual ['a, 'r, 's] eff =
                          ['a, 'r, 's] Eval.T2(M).eff
                        class virtual ['a, 'r, 's] t :
                          object
                            method division_by_zero : unit -> ('r, 'a) state
                            method eval_binop :
                              binop -> exp -> exp -> ('r, 'a) M.t
                            method eval_cast :
                              cast -> int -> exp -> ('r, 'a) M.t
                            method eval_concat : exp -> exp -> ('r, 'a) M.t
                            method eval_exp : exp -> ('r, 'a) M.t
                            method eval_extract :
                              int -> int -> exp -> ('r, 'a) M.t
                            method eval_int : word -> ('r, 'a) M.t
                            method eval_ite :
                              cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                            method eval_let :
                              var -> exp -> exp -> ('r, 'a) M.t
                            method eval_load :
                              mem:exp ->
                              addr:exp -> endian -> size -> ('r, 'a) M.t
                            method eval_store :
                              mem:exp ->
                              addr:exp ->
                              exp -> endian -> size -> ('r, 'a) M.t
                            method eval_unknown :
                              Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                            method eval_unop : unop -> exp -> ('r, 'a) M.t
                            method eval_var : var -> ('r, 'a) M.t
                            method virtual load : '-> addr -> ('r, 'a) M.t
                            method virtual lookup : var -> ('r, 'a) M.t
                            method private virtual storage_of_value :
                              '-> ('s option, 'a) M.t
                            method virtual store :
                              '-> addr -> word -> ('r, 'a) M.t
                            method type_error : type_error -> ('r, 'a) state
                            method private virtual undefined : ('r, 'a) M.t
                            method virtual update :
                              var -> '-> (unit, 'a) M.t
                            method private virtual value_of_word :
                              word -> ('r, 'a) M.t
                            method private virtual word_of_value :
                              '-> (word option, 'a) M.t
                          end
                      end
                    class ['a] t :
                      object
                        constraint 'a = #Expi.context
                        method division_by_zero : unit -> 'a r
                        method empty : Bil.storage
                        method eval_binop :
                          binop -> exp -> exp -> (Bil.result, 'a) M.t
                        method eval_cast :
                          cast -> int -> exp -> (Bil.result, 'a) M.t
                        method eval_concat :
                          exp -> exp -> (Bil.result, 'a) M.t
                        method eval_exp : exp -> (Bil.result, 'a) M.t
                        method eval_extract :
                          int -> int -> exp -> (Bil.result, 'a) M.t
                        method eval_int : word -> (Bil.result, 'a) M.t
                        method eval_ite :
                          cond:exp ->
                          yes:exp -> no:exp -> (Bil.result, 'a) M.t
                        method eval_let :
                          var -> exp -> exp -> (Bil.result, 'a) M.t
                        method eval_load :
                          mem:exp ->
                          addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                        method eval_store :
                          mem:exp ->
                          addr:exp ->
                          exp -> endian -> size -> (Bil.result, 'a) M.t
                        method eval_unknown :
                          Trie.String.Suffix.key ->
                          typ -> (Bil.result, 'a) M.t
                        method eval_unop :
                          unop -> exp -> (Bil.result, 'a) M.t
                        method eval_var : var -> (Bil.result, 'a) M.t
                        method load : Bil.storage -> addr -> 'a r
                        method lookup : var -> 'a r
                        method store : Bil.storage -> addr -> word -> 'a r
                        method type_error : type_error -> 'a r
                        method undefined_addr : addr -> 'a r
                        method undefined_var : var -> 'a r
                        method update : var -> Bil.result -> 'a u
                      end
                  end
                class ['a] t :
                  object
                    constraint 'a = #context
                    method division_by_zero : unit -> 'Expi.r
                    method empty : Bil.storage
                    method enter_term : ('p, 't) cls -> 't term -> 'a u
                    method eval : ('p, 't) cls -> 't term -> 'a u
                    method eval_arg : arg term -> 'a u
                    method eval_binop :
                      binop -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_blk : blk term -> 'a u
                    method eval_call : call -> 'a u
                    method eval_cast :
                      cast -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                    method eval_def : def term -> 'a u
                    method eval_direct : tid -> 'a u
                    method eval_exn : int -> tid -> 'a u
                    method eval_exp : exp -> (Bil.result, 'a) M.t
                    method eval_extract :
                      int -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_goto : label -> 'a u
                    method eval_indirect : exp -> 'a u
                    method eval_int : word -> (Bil.result, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                    method eval_jmp : jmp term -> 'a u
                    method eval_let :
                      var -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_load :
                      mem:exp ->
                      addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_phi : phi term -> 'a u
                    method eval_ret : label -> 'a u
                    method eval_store :
                      mem:exp ->
                      addr:exp ->
                      exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_sub : sub term -> 'a u
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                    method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                    method eval_var : var -> (Bil.result, 'a) M.t
                    method leave_term : ('p, 't) cls -> 't term -> 'a u
                    method load : Bil.storage -> addr -> 'Expi.r
                    method lookup : var -> 'Expi.r
                    method store : Bil.storage -> addr -> word -> 'Expi.r
                    method type_error : type_error -> 'Expi.r
                    method undefined_addr : addr -> 'Expi.r
                    method undefined_var : var -> 'Expi.r
                    method update : var -> Bil.result -> 'Expi.u
                  end
              end
          type ('a, 'e) state = ('a, 'e) Bili.state
          type 'a u = (unit, 'a) state
          type 'a r = (Bil.result, 'a) state
          module Expi :
            sig
              type ('a, 'e) state = ('a, 'e) Bili.state
              type 'a u = (unit, 'a) state
              type 'a r = (Bil.result, 'a) state
              module M : sig type ('a, 'e) t = ('a, 'e) state end
              module Eval :
                sig
                  class type ['a, 'r] semantics =
                    ['a, 'r] Eval.T2(M).semantics
                  class type virtual ['a, 'r, 's] domain =
                    ['a, 'r, 's] Eval.T2(M).domain
                  class type virtual ['a, 'r, 's] eff =
                    ['a, 'r, 's] Eval.T2(M).eff
                  class virtual ['a, 'r, 's] t :
                    object
                      method division_by_zero : unit -> ('r, 'a) state
                      method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                      method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                      method eval_concat : exp -> exp -> ('r, 'a) M.t
                      method eval_exp : exp -> ('r, 'a) M.t
                      method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                      method eval_int : word -> ('r, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                      method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                      method eval_load :
                        mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                      method eval_unop : unop -> exp -> ('r, 'a) M.t
                      method eval_var : var -> ('r, 'a) M.t
                      method virtual load : '-> addr -> ('r, 'a) M.t
                      method virtual lookup : var -> ('r, 'a) M.t
                      method private virtual storage_of_value :
                        '-> ('s option, 'a) M.t
                      method virtual store :
                        '-> addr -> word -> ('r, 'a) M.t
                      method type_error : type_error -> ('r, 'a) state
                      method private virtual undefined : ('r, 'a) M.t
                      method virtual update : var -> '-> (unit, 'a) M.t
                      method private virtual value_of_word :
                        word -> ('r, 'a) M.t
                      method private virtual word_of_value :
                        '-> (word option, 'a) M.t
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Expi.context
                  method division_by_zero : unit -> 'a r
                  method empty : Bil.storage
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method load : Bil.storage -> addr -> 'a r
                  method lookup : var -> 'a r
                  method store : Bil.storage -> addr -> word -> 'a r
                  method type_error : type_error -> 'a r
                  method undefined_addr : addr -> 'a r
                  method undefined_var : var -> 'a r
                  method update : var -> Bil.result -> 'a u
                end
            end
          class ['a] t :
            object
              constraint 'a = #context
              method division_by_zero : unit -> 'Expi.r
              method empty : Bil.storage
              method enter_term : ('p, 't) cls -> 't term -> 'a u
              method eval : ('p, 't) cls -> 't term -> 'a u
              method eval_arg : arg term -> 'a u
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_blk : blk term -> 'a u
              method eval_call : call -> 'a u
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_def : def term -> 'a u
              method eval_direct : tid -> 'a u
              method eval_exn : int -> tid -> 'a u
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_goto : label -> 'a u
              method eval_indirect : exp -> 'a u
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_jmp : jmp term -> 'a u
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_phi : phi term -> 'a u
              method eval_ret : label -> 'a u
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_sub : sub term -> 'a u
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method leave_term : ('p, 't) cls -> 't term -> 'a u
              method load : Bil.storage -> addr -> 'Expi.r
              method lookup : var -> 'Expi.r
              method store : Bil.storage -> addr -> word -> 'Expi.r
              method type_error : type_error -> 'Expi.r
              method undefined_addr : addr -> 'Expi.r
              method undefined_var : var -> 'Expi.r
              method update : var -> Bil.result -> 'Expi.u
            end
        end
      class ['a] biri :
        object
          constraint 'a = #Bap.Std.Biri.context
          method division_by_zero : unit -> 'Biri.Expi.r
          method empty : Bil.storage
          method enter_term : ('p, 't) cls -> 't term -> 'Biri.u
          method eval : ('p, 't) cls -> 't term -> 'Biri.u
          method eval_arg : arg term -> 'Biri.u
          method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_blk : blk term -> 'Biri.u
          method eval_call : call -> 'Biri.u
          method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
          method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
          method eval_def : def term -> 'Biri.u
          method eval_direct : tid -> 'Biri.u
          method eval_exn : int -> tid -> 'Biri.u
          method eval_exp : exp -> (Bil.result, 'a) M.t
          method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
          method eval_goto : label -> 'Biri.u
          method eval_indirect : exp -> 'Biri.u
          method eval_int : word -> (Bil.result, 'a) M.t
          method eval_ite :
            cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
          method eval_jmp : jmp term -> 'Biri.u
          method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
          method eval_load :
            mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_phi : phi term -> 'Biri.u
          method eval_ret : label -> 'Biri.u
          method eval_store :
            mem:exp ->
            addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
          method eval_sub : sub term -> 'Biri.u
          method eval_unknown :
            Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
          method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
          method eval_var : var -> (Bil.result, 'a) M.t
          method leave_term : ('p, 't) cls -> 't term -> 'Biri.u
          method load : Bil.storage -> addr -> 'Biri.Expi.r
          method lookup : var -> 'Biri.Expi.r
          method store : Bil.storage -> addr -> word -> 'Biri.Expi.r
          method type_error : type_error -> 'Biri.Expi.r
          method undefined_addr : addr -> 'Biri.Expi.r
          method undefined_var : var -> 'Biri.Expi.r
          method update : var -> Bil.result -> 'Biri.Expi.u
        end
      type color =
          [ `black
          | `blue
          | `cyan
          | `gray
          | `green
          | `magenta
          | `red
          | `white
          | `yellow ]
      val bin_color : color Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_color : color Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_color__ :
        (int -> color) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_color : color Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_color : color Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_color : color Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_color : color Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_color : Core_kernel.Std.Bin_prot.Shape.t
      val compare_color : color -> color -> int
      val color_of_sexp : Sexplib.Sexp.t -> color
      val __color_of_sexp__ : Sexplib.Sexp.t -> color
      val sexp_of_color : color -> Sexplib.Sexp.t
      val color : Bap.Std.color Bap.Std.tag
      val foreground : Bap.Std.color Bap.Std.tag
      val background : Bap.Std.color Bap.Std.tag
      val comment : string Bap.Std.tag
      val python : string Bap.Std.tag
      val shell : string Bap.Std.tag
      val mark : unit Bap.Std.tag
      val weight : float Bap.Std.tag
      val address : Bap.Std.addr Bap.Std.tag
      val filename : string Bap.Std.tag
      type image
      type mem
      val sexp_of_mem : mem -> Sexplib.Sexp.t
      type 'a table
      val sexp_of_table :
        ('-> Sexplib.Sexp.t) -> 'a table -> Sexplib.Sexp.t
      type 'a memmap
      val sexp_of_memmap :
        ('-> Sexplib.Sexp.t) -> 'a memmap -> Sexplib.Sexp.t
      module type Memory_iterators =
        sig
          type t
          type 'a m
          val fold :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            init:'->
            f:(Bap.Std.word -> '-> 'Bap.Std.Memory_iterators.m) ->
            'Bap.Std.Memory_iterators.m
          val iter :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            f:(Bap.Std.word -> unit Bap.Std.Memory_iterators.m) ->
            unit Bap.Std.Memory_iterators.m
          val foldi :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            init:'->
            f:(Bap.Std.addr ->
               Bap.Std.word -> '-> 'Bap.Std.Memory_iterators.m) ->
            'Bap.Std.Memory_iterators.m
          val iteri :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            f:(Bap.Std.addr ->
               Bap.Std.word -> unit Bap.Std.Memory_iterators.m) ->
            unit Bap.Std.Memory_iterators.m
          val exists :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            f:(Bap.Std.addr ->
               Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
            bool Bap.Std.Memory_iterators.m
          val for_all :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            f:(Bap.Std.addr ->
               Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
            bool Bap.Std.Memory_iterators.m
          val count :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            f:(Bap.Std.addr ->
               Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
            int Bap.Std.Memory_iterators.m
          val find_if :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            f:(Bap.Std.addr ->
               Bap.Std.word -> bool Bap.Std.Memory_iterators.m) ->
            Bap.Std.word option Bap.Std.Memory_iterators.m
          val find_map :
            ?word_size:Bap.Std.size ->
            Bap.Std.Memory_iterators.t ->
            f:(Bap.Std.addr ->
               Bap.Std.word -> 'a option Bap.Std.Memory_iterators.m) ->
            'a option Bap.Std.Memory_iterators.m
        end
      module Memory :
        sig
          type t = Bap.Std.mem
          val sexp_of_t : t -> Sexplib.Sexp.t
          val create :
            ?pos:int ->
            ?len:int ->
            Bap.Std.endian ->
            Bap.Std.addr ->
            Core_kernel.Std.Bigstring.t ->
            Bap.Std.Memory.t Core_kernel.Std.Or_error.t
          val of_file :
            Bap.Std.endian ->
            Bap.Std.addr ->
            string -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
          val view :
            ?word_size:Bap.Std.size ->
            ?from:Bap.Std.addr ->
            ?words:int ->
            Bap.Std.Memory.t -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
          val range :
            Bap.Std.Memory.t ->
            Bap.Std.addr ->
            Bap.Std.addr -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
          val merge :
            Bap.Std.Memory.t ->
            Bap.Std.Memory.t -> Bap.Std.Memory.t Core_kernel.Std.Or_error.t
          val first_byte : Bap.Std.Memory.t -> Bap.Std.Memory.t
          val last_byte : Bap.Std.Memory.t -> Bap.Std.Memory.t
          val endian : Bap.Std.Memory.t -> Bap.Std.endian
          val get :
            ?disp:int ->
            ?index:int ->
            ?scale:Bap.Std.size ->
            ?addr:Bap.Std.addr ->
            Bap.Std.Memory.t -> Bap.Std.word Core_kernel.Std.Or_error.t
          val ( ^ ) :
            Bap.Std.Memory.t ->
            Bap.Std.addr -> Bap.Std.word Core_kernel.Std.Or_error.t
          val ( ^! ) : Bap.Std.Memory.t -> Bap.Std.addr -> Bap.Std.word
          val max_addr : Bap.Std.Memory.t -> Bap.Std.addr
          val min_addr : Bap.Std.Memory.t -> Bap.Std.addr
          val length : Bap.Std.Memory.t -> int
          val contains : Bap.Std.Memory.t -> Bap.Std.addr -> bool
          val compare_with :
            Bap.Std.Memory.t ->
            Bap.Std.addr ->
            [ `addr_is_above | `addr_is_below | `addr_is_inside ]
          module Input :
            sig
              type 'a reader =
                  Bap.Std.Memory.t ->
                  pos_ref:Bap.Std.addr Core_kernel.Std.ref ->
                  'Core_kernel.Std.Or_error.t
              val word :
                word_size:Bap.Std.size ->
                Bap.Std.word Bap.Std.Memory.Input.reader
              val int8 : Bap.Std.word Bap.Std.Memory.Input.reader
              val uint8 : Bap.Std.word Bap.Std.Memory.Input.reader
              val int16 : Bap.Std.word Bap.Std.Memory.Input.reader
              val uint16 : Bap.Std.word Bap.Std.Memory.Input.reader
              val int32 : Bap.Std.word Bap.Std.Memory.Input.reader
              val int64 : Bap.Std.word Bap.Std.Memory.Input.reader
            end
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val hexdump : Bap.Std.Memory.t -> string
          type 'a m = 'a
          val fold :
            ?word_size:size -> t -> init:'-> f:(word -> '-> 'b) -> 'b
          val iter : ?word_size:size -> t -> f:(word -> unit) -> unit
          val foldi :
            ?word_size:size ->
            t -> init:'-> f:(addr -> word -> '-> 'b) -> 'b
          val iteri :
            ?word_size:size -> t -> f:(addr -> word -> unit) -> unit
          val exists :
            ?word_size:size -> t -> f:(addr -> word -> bool) -> bool
          val for_all :
            ?word_size:size -> t -> f:(addr -> word -> bool) -> bool
          val count : ?word_size:size -> t -> f:(addr -> word -> bool) -> int
          val find_if :
            ?word_size:size -> t -> f:(addr -> word -> bool) -> word option
          val find_map :
            ?word_size:size ->
            t -> f:(addr -> word -> 'a option) -> 'a option
          module With_error :
            sig
              type 'a m = 'Core_kernel.Std.Or_error.t
              val fold :
                ?word_size:size ->
                t -> init:'-> f:(word -> '-> 'b m) -> 'b m
              val iter : ?word_size:size -> t -> f:(word -> unit m) -> unit m
              val foldi :
                ?word_size:size ->
                t -> init:'-> f:(addr -> word -> '-> 'b m) -> 'b m
              val iteri :
                ?word_size:size -> t -> f:(addr -> word -> unit m) -> unit m
              val exists :
                ?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
              val for_all :
                ?word_size:size -> t -> f:(addr -> word -> bool m) -> bool m
              val count :
                ?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
              val find_if :
                ?word_size:size ->
                t -> f:(addr -> word -> bool m) -> word option m
              val find_map :
                ?word_size:size ->
                t -> f:(addr -> word -> 'a option m) -> 'a option m
            end
          module Make_iterators :
            functor (M : Legacy.Monad.S->
              sig
                type 'a m = 'M.t
                val fold :
                  ?word_size:size ->
                  t -> init:'-> f:(word -> '-> 'b m) -> 'b m
                val iter :
                  ?word_size:size -> t -> f:(word -> unit m) -> unit m
                val foldi :
                  ?word_size:size ->
                  t -> init:'-> f:(addr -> word -> '-> 'b m) -> 'b m
                val iteri :
                  ?word_size:size ->
                  t -> f:(addr -> word -> unit m) -> unit m
                val exists :
                  ?word_size:size ->
                  t -> f:(addr -> word -> bool m) -> bool m
                val for_all :
                  ?word_size:size ->
                  t -> f:(addr -> word -> bool m) -> bool m
                val count :
                  ?word_size:size -> t -> f:(addr -> word -> bool m) -> int m
                val find_if :
                  ?word_size:size ->
                  t -> f:(addr -> word -> bool m) -> word option m
                val find_map :
                  ?word_size:size ->
                  t -> f:(addr -> word -> 'a option m) -> 'a option m
              end
          val to_buffer : Bap.Std.Memory.t -> Core_kernel.Std.Bigsubstring.t
          module Trie :
            sig
              module Stable :
                sig
                  module V1 :
                    sig
                      module R8 :
                        sig
                          type 'a t
                          val bin_t :
                            'Core_kernel.Std.Bin_prot.Type_class.t ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.t
                          val bin_read_t :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            'a t Core_kernel.Std.Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            (int -> 'a t)
                            Core_kernel.Std.Bin_prot.Read.reader
                          val bin_reader_t :
                            'Core_kernel.Std.Bin_prot.Type_class.reader ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Core_kernel.Std.Bin_prot.Size.sizer ->
                            'a t Core_kernel.Std.Bin_prot.Size.sizer
                          val bin_write_t :
                            'Core_kernel.Std.Bin_prot.Write.writer ->
                            'a t Core_kernel.Std.Bin_prot.Write.writer
                          val bin_writer_t :
                            'Core_kernel.Std.Bin_prot.Type_class.writer ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Core_kernel.Std.Bin_prot.Shape.t ->
                            Core_kernel.Std.Bin_prot.Shape.t
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          type key = Bap.Std.mem
                          val create : unit -> 'a t
                          val add : 'a t -> key:key -> data:'-> unit
                          val change :
                            'a t -> key -> ('a option -> 'a option) -> unit
                          val find : 'a t -> key -> 'a option
                          val walk :
                            'a t ->
                            key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                          val remove : 'a t -> key -> unit
                          val longest_match :
                            'a t -> key -> (int * 'a) option
                          val length : 'a t -> int
                          val pp :
                            'Regular.Std.printer ->
                            'a t Regular.Std.printer
                        end
                      module R16 :
                        sig
                          type 'a t
                          val bin_t :
                            'Core_kernel.Std.Bin_prot.Type_class.t ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.t
                          val bin_read_t :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            'a t Core_kernel.Std.Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            (int -> 'a t)
                            Core_kernel.Std.Bin_prot.Read.reader
                          val bin_reader_t :
                            'Core_kernel.Std.Bin_prot.Type_class.reader ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Core_kernel.Std.Bin_prot.Size.sizer ->
                            'a t Core_kernel.Std.Bin_prot.Size.sizer
                          val bin_write_t :
                            'Core_kernel.Std.Bin_prot.Write.writer ->
                            'a t Core_kernel.Std.Bin_prot.Write.writer
                          val bin_writer_t :
                            'Core_kernel.Std.Bin_prot.Type_class.writer ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Core_kernel.Std.Bin_prot.Shape.t ->
                            Core_kernel.Std.Bin_prot.Shape.t
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          type key = R8.key
                          val create : unit -> 'a t
                          val add : 'a t -> key:key -> data:'-> unit
                          val change :
                            'a t -> key -> ('a option -> 'a option) -> unit
                          val find : 'a t -> key -> 'a option
                          val walk :
                            'a t ->
                            key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                          val remove : 'a t -> key -> unit
                          val longest_match :
                            'a t -> key -> (int * 'a) option
                          val length : 'a t -> int
                          val pp :
                            'Regular.Std.printer ->
                            'a t Regular.Std.printer
                        end
                      module R32 :
                        sig
                          type 'a t
                          val bin_t :
                            'Core_kernel.Std.Bin_prot.Type_class.t ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.t
                          val bin_read_t :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            'a t Core_kernel.Std.Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            (int -> 'a t)
                            Core_kernel.Std.Bin_prot.Read.reader
                          val bin_reader_t :
                            'Core_kernel.Std.Bin_prot.Type_class.reader ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Core_kernel.Std.Bin_prot.Size.sizer ->
                            'a t Core_kernel.Std.Bin_prot.Size.sizer
                          val bin_write_t :
                            'Core_kernel.Std.Bin_prot.Write.writer ->
                            'a t Core_kernel.Std.Bin_prot.Write.writer
                          val bin_writer_t :
                            'Core_kernel.Std.Bin_prot.Type_class.writer ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Core_kernel.Std.Bin_prot.Shape.t ->
                            Core_kernel.Std.Bin_prot.Shape.t
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          type key = R16.key
                          val create : unit -> 'a t
                          val add : 'a t -> key:key -> data:'-> unit
                          val change :
                            'a t -> key -> ('a option -> 'a option) -> unit
                          val find : 'a t -> key -> 'a option
                          val walk :
                            'a t ->
                            key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                          val remove : 'a t -> key -> unit
                          val longest_match :
                            'a t -> key -> (int * 'a) option
                          val length : 'a t -> int
                          val pp :
                            'Regular.Std.printer ->
                            'a t Regular.Std.printer
                        end
                      module R64 :
                        sig
                          type 'a t
                          val bin_t :
                            'Core_kernel.Std.Bin_prot.Type_class.t ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.t
                          val bin_read_t :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            'a t Core_kernel.Std.Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            (int -> 'a t)
                            Core_kernel.Std.Bin_prot.Read.reader
                          val bin_reader_t :
                            'Core_kernel.Std.Bin_prot.Type_class.reader ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Core_kernel.Std.Bin_prot.Size.sizer ->
                            'a t Core_kernel.Std.Bin_prot.Size.sizer
                          val bin_write_t :
                            'Core_kernel.Std.Bin_prot.Write.writer ->
                            'a t Core_kernel.Std.Bin_prot.Write.writer
                          val bin_writer_t :
                            'Core_kernel.Std.Bin_prot.Type_class.writer ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Core_kernel.Std.Bin_prot.Shape.t ->
                            Core_kernel.Std.Bin_prot.Shape.t
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          type key = R32.key
                          val create : unit -> 'a t
                          val add : 'a t -> key:key -> data:'-> unit
                          val change :
                            'a t -> key -> ('a option -> 'a option) -> unit
                          val find : 'a t -> key -> 'a option
                          val walk :
                            'a t ->
                            key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                          val remove : 'a t -> key -> unit
                          val longest_match :
                            'a t -> key -> (int * 'a) option
                          val length : 'a t -> int
                          val pp :
                            'Regular.Std.printer ->
                            'a t Regular.Std.printer
                        end
                    end
                  module V2 :
                    sig
                      module R8 :
                        sig
                          type 'a t
                          val bin_t :
                            'Core_kernel.Std.Bin_prot.Type_class.t ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.t
                          val bin_read_t :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            'a t Core_kernel.Std.Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            (int -> 'a t)
                            Core_kernel.Std.Bin_prot.Read.reader
                          val bin_reader_t :
                            'Core_kernel.Std.Bin_prot.Type_class.reader ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Core_kernel.Std.Bin_prot.Size.sizer ->
                            'a t Core_kernel.Std.Bin_prot.Size.sizer
                          val bin_write_t :
                            'Core_kernel.Std.Bin_prot.Write.writer ->
                            'a t Core_kernel.Std.Bin_prot.Write.writer
                          val bin_writer_t :
                            'Core_kernel.Std.Bin_prot.Type_class.writer ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Core_kernel.Std.Bin_prot.Shape.t ->
                            Core_kernel.Std.Bin_prot.Shape.t
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          type key = V1.R8.key
                          val create : unit -> 'a t
                          val add : 'a t -> key:key -> data:'-> unit
                          val change :
                            'a t -> key -> ('a option -> 'a option) -> unit
                          val find : 'a t -> key -> 'a option
                          val walk :
                            'a t ->
                            key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                          val remove : 'a t -> key -> unit
                          val longest_match :
                            'a t -> key -> (int * 'a) option
                          val length : 'a t -> int
                          val pp :
                            'Regular.Std.printer ->
                            'a t Regular.Std.printer
                        end
                      module R16 :
                        sig
                          type 'a t
                          val bin_t :
                            'Core_kernel.Std.Bin_prot.Type_class.t ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.t
                          val bin_read_t :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            'a t Core_kernel.Std.Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            (int -> 'a t)
                            Core_kernel.Std.Bin_prot.Read.reader
                          val bin_reader_t :
                            'Core_kernel.Std.Bin_prot.Type_class.reader ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Core_kernel.Std.Bin_prot.Size.sizer ->
                            'a t Core_kernel.Std.Bin_prot.Size.sizer
                          val bin_write_t :
                            'Core_kernel.Std.Bin_prot.Write.writer ->
                            'a t Core_kernel.Std.Bin_prot.Write.writer
                          val bin_writer_t :
                            'Core_kernel.Std.Bin_prot.Type_class.writer ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Core_kernel.Std.Bin_prot.Shape.t ->
                            Core_kernel.Std.Bin_prot.Shape.t
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          type key = R8.key
                          val create : unit -> 'a t
                          val add : 'a t -> key:key -> data:'-> unit
                          val change :
                            'a t -> key -> ('a option -> 'a option) -> unit
                          val find : 'a t -> key -> 'a option
                          val walk :
                            'a t ->
                            key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                          val remove : 'a t -> key -> unit
                          val longest_match :
                            'a t -> key -> (int * 'a) option
                          val length : 'a t -> int
                          val pp :
                            'Regular.Std.printer ->
                            'a t Regular.Std.printer
                        end
                      module R32 :
                        sig
                          type 'a t
                          val bin_t :
                            'Core_kernel.Std.Bin_prot.Type_class.t ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.t
                          val bin_read_t :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            'a t Core_kernel.Std.Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            (int -> 'a t)
                            Core_kernel.Std.Bin_prot.Read.reader
                          val bin_reader_t :
                            'Core_kernel.Std.Bin_prot.Type_class.reader ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Core_kernel.Std.Bin_prot.Size.sizer ->
                            'a t Core_kernel.Std.Bin_prot.Size.sizer
                          val bin_write_t :
                            'Core_kernel.Std.Bin_prot.Write.writer ->
                            'a t Core_kernel.Std.Bin_prot.Write.writer
                          val bin_writer_t :
                            'Core_kernel.Std.Bin_prot.Type_class.writer ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Core_kernel.Std.Bin_prot.Shape.t ->
                            Core_kernel.Std.Bin_prot.Shape.t
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          type key = R16.key
                          val create : unit -> 'a t
                          val add : 'a t -> key:key -> data:'-> unit
                          val change :
                            'a t -> key -> ('a option -> 'a option) -> unit
                          val find : 'a t -> key -> 'a option
                          val walk :
                            'a t ->
                            key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                          val remove : 'a t -> key -> unit
                          val longest_match :
                            'a t -> key -> (int * 'a) option
                          val length : 'a t -> int
                          val pp :
                            'Regular.Std.printer ->
                            'a t Regular.Std.printer
                        end
                      module R64 :
                        sig
                          type 'a t
                          val bin_t :
                            'Core_kernel.Std.Bin_prot.Type_class.t ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.t
                          val bin_read_t :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            'a t Core_kernel.Std.Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Core_kernel.Std.Bin_prot.Read.reader ->
                            (int -> 'a t)
                            Core_kernel.Std.Bin_prot.Read.reader
                          val bin_reader_t :
                            'Core_kernel.Std.Bin_prot.Type_class.reader ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Core_kernel.Std.Bin_prot.Size.sizer ->
                            'a t Core_kernel.Std.Bin_prot.Size.sizer
                          val bin_write_t :
                            'Core_kernel.Std.Bin_prot.Write.writer ->
                            'a t Core_kernel.Std.Bin_prot.Write.writer
                          val bin_writer_t :
                            'Core_kernel.Std.Bin_prot.Type_class.writer ->
                            'a t Core_kernel.Std.Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Core_kernel.Std.Bin_prot.Shape.t ->
                            Core_kernel.Std.Bin_prot.Shape.t
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                          type key = R32.key
                          val create : unit -> 'a t
                          val add : 'a t -> key:key -> data:'-> unit
                          val change :
                            'a t -> key -> ('a option -> 'a option) -> unit
                          val find : 'a t -> key -> 'a option
                          val walk :
                            'a t ->
                            key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                          val remove : 'a t -> key -> unit
                          val longest_match :
                            'a t -> key -> (int * 'a) option
                          val length : 'a t -> int
                          val pp :
                            'Regular.Std.printer ->
                            'a t Regular.Std.printer
                        end
                    end
                end
              module R8 :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  type key = Stable.V2.R8.key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module R16 :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  type key = R8.key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module R32 :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  type key = R16.key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              module R64 :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  type key = R32.key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
            end
        end
      module Table :
        sig
          type 'a t = 'Bap.Std.table
          val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          type 'a hashable = 'Core_kernel.Std.Hashtbl.Hashable.t
          val empty : 'Bap.Std.Table.t
          val singleton : Bap.Std.mem -> '-> 'Bap.Std.Table.t
          val add :
            'Bap.Std.Table.t ->
            Bap.Std.mem ->
            '-> 'Bap.Std.Table.t Core_kernel.Std.Or_error.t
          val remove :
            'Bap.Std.Table.t -> Bap.Std.mem -> 'Bap.Std.Table.t
          val change :
            'Bap.Std.Table.t ->
            Bap.Std.mem ->
            f:((Bap.Std.mem * 'a) Bap.Std.seq ->
               [ `ignore
               | `rebind of Bap.Std.mem * 'a
               | `remove
               | `update of Bap.Std.mem * '-> 'a ]) ->
            'Bap.Std.Table.t
          val length : 'Bap.Std.Table.t -> int
          val find : 'Bap.Std.Table.t -> Bap.Std.mem -> 'a option
          val find_addr :
            'Bap.Std.Table.t -> Bap.Std.addr -> (Bap.Std.mem * 'a) option
          val intersections :
            'Bap.Std.Table.t ->
            Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
          val fold_intersections :
            'Bap.Std.Table.t ->
            Bap.Std.mem -> init:'-> f:(Bap.Std.mem -> '-> '-> 'b) -> 'b
          val has_intersections : 'Bap.Std.Table.t -> Bap.Std.mem -> bool
          val mem : 'Bap.Std.Table.t -> Bap.Std.mem -> bool
          val next :
            'Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) option
          val prev :
            'Bap.Std.Table.t -> Bap.Std.mem -> (Bap.Std.mem * 'a) option
          val min : 'Bap.Std.Table.t -> (Bap.Std.mem * 'a) option
          val max : 'Bap.Std.Table.t -> (Bap.Std.mem * 'a) option
          type ('a, 'm) r
          val many : ('a, 'Bap.Std.seq) Bap.Std.Table.r
          val at_least_one : ('a, 'a * 'Bap.Std.seq) Bap.Std.Table.r
          val one : ('a, 'a) Bap.Std.Table.r
          val maybe_one : ('a, 'a option) Bap.Std.Table.r
          val link :
            one_to:('b, 'r) Bap.Std.Table.r ->
            'Bap.Std.Table.hashable ->
            'Bap.Std.Table.t -> 'Bap.Std.Table.t -> '-> 'r
          val rev_map :
            one_to:(Bap.Std.mem, 'r) Bap.Std.Table.r ->
            'Bap.Std.Table.hashable ->
            'Bap.Std.Table.t -> ('-> 'r) Core_kernel.Std.Or_error.t
          type 'a ranged = ?start:Bap.Std.mem -> ?until:Bap.Std.mem -> 'a
          val exists :
            ('Bap.Std.Table.t -> f:('-> bool) -> bool)
            Bap.Std.Table.ranged
          val for_all :
            ('Bap.Std.Table.t -> f:('-> bool) -> bool)
            Bap.Std.Table.ranged
          val existsi :
            ('Bap.Std.Table.t -> f:(Bap.Std.mem -> '-> bool) -> bool)
            Bap.Std.Table.ranged
          val for_alli :
            ('Bap.Std.Table.t -> f:(Bap.Std.mem -> '-> bool) -> bool)
            Bap.Std.Table.ranged
          val count :
            ('Bap.Std.Table.t -> f:('-> bool) -> int)
            Bap.Std.Table.ranged
          val find_if :
            ('Bap.Std.Table.t -> f:('-> bool) -> 'a option)
            Bap.Std.Table.ranged
          val find_map :
            ('Bap.Std.Table.t -> f:('-> 'b option) -> 'b option)
            Bap.Std.Table.ranged
          val fold :
            ('Bap.Std.Table.t -> init:'-> f:('-> '-> 'b) -> 'b)
            Bap.Std.Table.ranged
          val iter :
            ('Bap.Std.Table.t -> f:('-> unit) -> unit)
            Bap.Std.Table.ranged
          val find_mapi :
            ('Bap.Std.Table.t ->
             f:(Bap.Std.mem -> '-> 'b option) -> 'b option)
            Bap.Std.Table.ranged
          val foldi :
            ('Bap.Std.Table.t ->
             init:'-> f:(Bap.Std.mem -> '-> '-> 'b) -> 'b)
            Bap.Std.Table.ranged
          val iteri :
            ('Bap.Std.Table.t -> f:(Bap.Std.mem -> '-> unit) -> unit)
            Bap.Std.Table.ranged
          val map :
            ('Bap.Std.Table.t -> f:('-> 'b) -> 'Bap.Std.Table.t)
            Bap.Std.Table.ranged
          val mapi :
            ('Bap.Std.Table.t ->
             f:(Bap.Std.mem -> '-> 'b) -> 'Bap.Std.Table.t)
            Bap.Std.Table.ranged
          val filter :
            ('Bap.Std.Table.t -> f:('-> bool) -> 'Bap.Std.Table.t)
            Bap.Std.Table.ranged
          val filter_map :
            ('Bap.Std.Table.t -> f:('-> 'b option) -> 'Bap.Std.Table.t)
            Bap.Std.Table.ranged
          val filteri :
            ('Bap.Std.Table.t ->
             f:(Bap.Std.mem -> '-> bool) -> 'Bap.Std.Table.t)
            Bap.Std.Table.ranged
          val filter_mapi :
            ('Bap.Std.Table.t ->
             f:(Bap.Std.mem -> '-> 'b option) -> 'Bap.Std.Table.t)
            Bap.Std.Table.ranged
          val to_sequence :
            ('Bap.Std.Table.t -> (Bap.Std.mem * 'a) Bap.Std.seq)
            Bap.Std.Table.ranged
          val regions :
            ('Bap.Std.Table.t -> Bap.Std.mem Bap.Std.seq)
            Bap.Std.Table.ranged
          val elements :
            ('Bap.Std.Table.t -> 'Bap.Std.seq) Bap.Std.Table.ranged
          val pp :
            'Regular.Std.printer -> 'Bap.Std.Table.t Regular.Std.printer
        end
      module Location :
        sig
          type t = { addr : Bap.Std.addr; len : int; }
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val compare : t -> t -> int
          val len : t -> int
          val addr : t -> addr
          module Fields :
            sig
              val names : Trie.String.Suffix.key list
              val len : (t, int) Fieldslib.Field.t
              val addr : (t, addr) Fieldslib.Field.t
              val fold :
                init:'acc__0 ->
                addr:('acc__0 -> (t, addr) Fieldslib.Field.t -> 'acc__1) ->
                len:('acc__1 -> (t, int) Fieldslib.Field.t -> 'acc__2) ->
                'acc__2
              val make_creator :
                addr:((t, addr) Fieldslib.Field.t ->
                      'acc__0 -> ('input__ -> addr) * 'acc__1) ->
                len:((t, int) Fieldslib.Field.t ->
                     'acc__1 -> ('input__ -> int) * 'acc__2) ->
                'acc__0 -> ('input__ -> t) * 'acc__2
              val create : addr:addr -> len:int -> t
              val map :
                addr:((t, addr) Fieldslib.Field.t -> addr) ->
                len:((t, int) Fieldslib.Field.t -> int) -> t
              val iter :
                addr:((t, addr) Fieldslib.Field.t -> unit) ->
                len:((t, int) Fieldslib.Field.t -> unit) -> unit
              val for_all :
                addr:((t, addr) Fieldslib.Field.t -> bool) ->
                len:((t, int) Fieldslib.Field.t -> bool) -> bool
              val exists :
                addr:((t, addr) Fieldslib.Field.t -> bool) ->
                len:((t, int) Fieldslib.Field.t -> bool) -> bool
              val to_list :
                addr:((t, addr) Fieldslib.Field.t -> 'elem__) ->
                len:((t, int) Fieldslib.Field.t -> 'elem__) -> 'elem__ list
              val map_poly :
                ([< `Read | `Set_and_create ], t, 'x0) Fieldslib.Field.user ->
                'x0 list
              module Direct :
                sig
                  val iter :
                    t ->
                    addr:((t, addr) Fieldslib.Field.t -> t -> addr -> unit) ->
                    len:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                    unit
                  val fold :
                    t ->
                    init:'acc__0 ->
                    addr:('acc__0 ->
                          (t, addr) Fieldslib.Field.t -> t -> addr -> 'acc__1) ->
                    len:('acc__1 ->
                         (t, int) Fieldslib.Field.t -> t -> int -> 'acc__2) ->
                    'acc__2
                  val for_all :
                    t ->
                    addr:((t, addr) Fieldslib.Field.t -> t -> addr -> bool) ->
                    len:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
                    bool
                  val exists :
                    t ->
                    addr:((t, addr) Fieldslib.Field.t -> t -> addr -> bool) ->
                    len:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
                    bool
                  val to_list :
                    t ->
                    addr:((t, addr) Fieldslib.Field.t -> t -> addr -> 'elem__) ->
                    len:((t, int) Fieldslib.Field.t -> t -> int -> 'elem__) ->
                    'elem__ list
                  val map :
                    t ->
                    addr:((t, addr) Fieldslib.Field.t -> t -> addr -> addr) ->
                    len:((t, int) Fieldslib.Field.t -> t -> int -> int) -> t
                  val set_all_mutable_fields : t -> unit
                end
            end
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
      type location = Bap.Std.Location.t
      val bin_location : location Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_location : location Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_location__ :
        (int -> location) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_location :
        location Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_location : location Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_location : location Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_location :
        location Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_location : Core_kernel.Std.Bin_prot.Shape.t
      val compare_location : location -> location -> int
      val location_of_sexp : Sexplib.Sexp.t -> location
      val sexp_of_location : location -> Sexplib.Sexp.t
      module Backend :
        sig
          type perm =
              R
            | W
            | X
            | Or of Bap.Std.Backend.perm * Bap.Std.Backend.perm
          val bin_perm : perm Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_perm : perm Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_perm__ :
            (int -> perm) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_perm :
            perm Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_perm : perm Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_perm : perm Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_perm :
            perm Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_perm : Core_kernel.Std.Bin_prot.Shape.t
          val compare_perm : perm -> perm -> int
          val perm_of_sexp : Sexplib.Sexp.t -> perm
          val sexp_of_perm : perm -> Sexplib.Sexp.t
          module Segment :
            sig
              type t = {
                name : string;
                perm : Bap.Std.Backend.perm;
                off : int;
                location : Bap.Std.location;
              }
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val compare : t -> t -> int
              val location : t -> location
              val off : t -> int
              val perm : t -> perm
              val name : t -> Trie.String.Suffix.key
              module Fields :
                sig
                  val names : Trie.String.Suffix.key list
                  val location : (t, location) Fieldslib.Field.t
                  val off : (t, int) Fieldslib.Field.t
                  val perm : (t, perm) Fieldslib.Field.t
                  val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
                  val fold :
                    init:'acc__0 ->
                    name:('acc__0 ->
                          (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'acc__1) ->
                    perm:('acc__1 -> (t, perm) Fieldslib.Field.t -> 'acc__2) ->
                    off:('acc__2 -> (t, int) Fieldslib.Field.t -> 'acc__3) ->
                    location:('acc__3 ->
                              (t, location) Fieldslib.Field.t -> 'acc__4) ->
                    'acc__4
                  val make_creator :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'acc__0 ->
                          ('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
                    perm:((t, perm) Fieldslib.Field.t ->
                          'acc__1 -> ('input__ -> perm) * 'acc__2) ->
                    off:((t, int) Fieldslib.Field.t ->
                         'acc__2 -> ('input__ -> int) * 'acc__3) ->
                    location:((t, location) Fieldslib.Field.t ->
                              'acc__3 -> ('input__ -> location) * 'acc__4) ->
                    'acc__0 -> ('input__ -> t) * 'acc__4
                  val create :
                    name:Trie.String.Suffix.key ->
                    perm:perm -> off:int -> location:location -> t
                  val map :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          Trie.String.Suffix.key) ->
                    perm:((t, perm) Fieldslib.Field.t -> perm) ->
                    off:((t, int) Fieldslib.Field.t -> int) ->
                    location:((t, location) Fieldslib.Field.t -> location) ->
                    t
                  val iter :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          unit) ->
                    perm:((t, perm) Fieldslib.Field.t -> unit) ->
                    off:((t, int) Fieldslib.Field.t -> unit) ->
                    location:((t, location) Fieldslib.Field.t -> unit) ->
                    unit
                  val for_all :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          bool) ->
                    perm:((t, perm) Fieldslib.Field.t -> bool) ->
                    off:((t, int) Fieldslib.Field.t -> bool) ->
                    location:((t, location) Fieldslib.Field.t -> bool) ->
                    bool
                  val exists :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          bool) ->
                    perm:((t, perm) Fieldslib.Field.t -> bool) ->
                    off:((t, int) Fieldslib.Field.t -> bool) ->
                    location:((t, location) Fieldslib.Field.t -> bool) ->
                    bool
                  val to_list :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'elem__) ->
                    perm:((t, perm) Fieldslib.Field.t -> 'elem__) ->
                    off:((t, int) Fieldslib.Field.t -> 'elem__) ->
                    location:((t, location) Fieldslib.Field.t -> 'elem__) ->
                    'elem__ list
                  val map_poly :
                    ([< `Read | `Set_and_create ], t, 'x0)
                    Fieldslib.Field.user -> 'x0 list
                  module Direct :
                    sig
                      val iter :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> unit) ->
                        perm:((t, perm) Fieldslib.Field.t ->
                              t -> perm -> unit) ->
                        off:((t, int) Fieldslib.Field.t -> t -> int -> unit) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> unit) ->
                        unit
                      val fold :
                        t ->
                        init:'acc__0 ->
                        name:('acc__0 ->
                              (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> 'acc__1) ->
                        perm:('acc__1 ->
                              (t, perm) Fieldslib.Field.t ->
                              t -> perm -> 'acc__2) ->
                        off:('acc__2 ->
                             (t, int) Fieldslib.Field.t ->
                             t -> int -> 'acc__3) ->
                        location:('acc__3 ->
                                  (t, location) Fieldslib.Field.t ->
                                  t -> location -> 'acc__4) ->
                        'acc__4
                      val for_all :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> bool) ->
                        perm:((t, perm) Fieldslib.Field.t ->
                              t -> perm -> bool) ->
                        off:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> bool) ->
                        bool
                      val exists :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> bool) ->
                        perm:((t, perm) Fieldslib.Field.t ->
                              t -> perm -> bool) ->
                        off:((t, int) Fieldslib.Field.t -> t -> int -> bool) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> bool) ->
                        bool
                      val to_list :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> 'elem__) ->
                        perm:((t, perm) Fieldslib.Field.t ->
                              t -> perm -> 'elem__) ->
                        off:((t, int) Fieldslib.Field.t ->
                             t -> int -> 'elem__) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> 'elem__) ->
                        'elem__ list
                      val map :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t ->
                              Trie.String.Suffix.key ->
                              Trie.String.Suffix.key) ->
                        perm:((t, perm) Fieldslib.Field.t ->
                              t -> perm -> perm) ->
                        off:((t, int) Fieldslib.Field.t -> t -> int -> int) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> location) ->
                        t
                      val set_all_mutable_fields : t -> unit
                    end
                end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          module Symbol :
            sig
              type t = {
                name : string;
                is_function : bool;
                is_debug : bool;
                locations : Bap.Std.location * Bap.Std.location list;
              }
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val compare : t -> t -> int
              val locations : t -> location * location list
              val is_debug : t -> bool
              val is_function : t -> bool
              val name : t -> Trie.String.Suffix.key
              module Fields :
                sig
                  val names : Trie.String.Suffix.key list
                  val locations :
                    (t, location * location list) Fieldslib.Field.t
                  val is_debug : (t, bool) Fieldslib.Field.t
                  val is_function : (t, bool) Fieldslib.Field.t
                  val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
                  val fold :
                    init:'acc__0 ->
                    name:('acc__0 ->
                          (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'acc__1) ->
                    is_function:('acc__1 ->
                                 (t, bool) Fieldslib.Field.t -> 'acc__2) ->
                    is_debug:('acc__2 ->
                              (t, bool) Fieldslib.Field.t -> 'acc__3) ->
                    locations:('acc__3 ->
                               (t, location * location list)
                               Fieldslib.Field.t -> 'acc__4) ->
                    'acc__4
                  val make_creator :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'acc__0 ->
                          ('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
                    is_function:((t, bool) Fieldslib.Field.t ->
                                 'acc__1 -> ('input__ -> bool) * 'acc__2) ->
                    is_debug:((t, bool) Fieldslib.Field.t ->
                              'acc__2 -> ('input__ -> bool) * 'acc__3) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t ->
                               'acc__3 ->
                               ('input__ -> location * location list) *
                               'acc__4) ->
                    'acc__0 -> ('input__ -> t) * 'acc__4
                  val create :
                    name:Trie.String.Suffix.key ->
                    is_function:bool ->
                    is_debug:bool -> locations:location * location list -> t
                  val map :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          Trie.String.Suffix.key) ->
                    is_function:((t, bool) Fieldslib.Field.t -> bool) ->
                    is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t -> location * location list) ->
                    t
                  val iter :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          unit) ->
                    is_function:((t, bool) Fieldslib.Field.t -> unit) ->
                    is_debug:((t, bool) Fieldslib.Field.t -> unit) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t -> unit) ->
                    unit
                  val for_all :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          bool) ->
                    is_function:((t, bool) Fieldslib.Field.t -> bool) ->
                    is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t -> bool) ->
                    bool
                  val exists :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          bool) ->
                    is_function:((t, bool) Fieldslib.Field.t -> bool) ->
                    is_debug:((t, bool) Fieldslib.Field.t -> bool) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t -> bool) ->
                    bool
                  val to_list :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'elem__) ->
                    is_function:((t, bool) Fieldslib.Field.t -> 'elem__) ->
                    is_debug:((t, bool) Fieldslib.Field.t -> 'elem__) ->
                    locations:((t, location * location list)
                               Fieldslib.Field.t -> 'elem__) ->
                    'elem__ list
                  val map_poly :
                    ([< `Read | `Set_and_create ], t, 'x0)
                    Fieldslib.Field.user -> 'x0 list
                  module Direct :
                    sig
                      val iter :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> unit) ->
                        is_function:((t, bool) Fieldslib.Field.t ->
                                     t -> bool -> unit) ->
                        is_debug:((t, bool) Fieldslib.Field.t ->
                                  t -> bool -> unit) ->
                        locations:((t, location * location list)
                                   Fieldslib.Field.t ->
                                   t -> location * location list -> unit) ->
                        unit
                      val fold :
                        t ->
                        init:'acc__0 ->
                        name:('acc__0 ->
                              (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> 'acc__1) ->
                        is_function:('acc__1 ->
                                     (t, bool) Fieldslib.Field.t ->
                                     t -> bool -> 'acc__2) ->
                        is_debug:('acc__2 ->
                                  (t, bool) Fieldslib.Field.t ->
                                  t -> bool -> 'acc__3) ->
                        locations:('acc__3 ->
                                   (t, location * location list)
                                   Fieldslib.Field.t ->
                                   t -> location * location list -> 'acc__4) ->
                        'acc__4
                      val for_all :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> bool) ->
                        is_function:((t, bool) Fieldslib.Field.t ->
                                     t -> bool -> bool) ->
                        is_debug:((t, bool) Fieldslib.Field.t ->
                                  t -> bool -> bool) ->
                        locations:((t, location * location list)
                                   Fieldslib.Field.t ->
                                   t -> location * location list -> bool) ->
                        bool
                      val exists :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> bool) ->
                        is_function:((t, bool) Fieldslib.Field.t ->
                                     t -> bool -> bool) ->
                        is_debug:((t, bool) Fieldslib.Field.t ->
                                  t -> bool -> bool) ->
                        locations:((t, location * location list)
                                   Fieldslib.Field.t ->
                                   t -> location * location list -> bool) ->
                        bool
                      val to_list :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> 'elem__) ->
                        is_function:((t, bool) Fieldslib.Field.t ->
                                     t -> bool -> 'elem__) ->
                        is_debug:((t, bool) Fieldslib.Field.t ->
                                  t -> bool -> 'elem__) ->
                        locations:((t, location * location list)
                                   Fieldslib.Field.t ->
                                   t -> location * location list -> 'elem__) ->
                        'elem__ list
                      val map :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t ->
                              Trie.String.Suffix.key ->
                              Trie.String.Suffix.key) ->
                        is_function:((t, bool) Fieldslib.Field.t ->
                                     t -> bool -> bool) ->
                        is_debug:((t, bool) Fieldslib.Field.t ->
                                  t -> bool -> bool) ->
                        locations:((t, location * location list)
                                   Fieldslib.Field.t ->
                                   t ->
                                   location * location list ->
                                   location * location list) ->
                        t
                      val set_all_mutable_fields : t -> unit
                    end
                end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          module Section :
            sig
              type t = { name : string; location : Bap.Std.location; }
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val compare : t -> t -> int
              val location : t -> location
              val name : t -> Trie.String.Suffix.key
              module Fields :
                sig
                  val names : Trie.String.Suffix.key list
                  val location : (t, location) Fieldslib.Field.t
                  val name : (t, Trie.String.Suffix.key) Fieldslib.Field.t
                  val fold :
                    init:'acc__0 ->
                    name:('acc__0 ->
                          (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'acc__1) ->
                    location:('acc__1 ->
                              (t, location) Fieldslib.Field.t -> 'acc__2) ->
                    'acc__2
                  val make_creator :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'acc__0 ->
                          ('input__ -> Trie.String.Suffix.key) * 'acc__1) ->
                    location:((t, location) Fieldslib.Field.t ->
                              'acc__1 -> ('input__ -> location) * 'acc__2) ->
                    'acc__0 -> ('input__ -> t) * 'acc__2
                  val create :
                    name:Trie.String.Suffix.key -> location:location -> t
                  val map :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          Trie.String.Suffix.key) ->
                    location:((t, location) Fieldslib.Field.t -> location) ->
                    t
                  val iter :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          unit) ->
                    location:((t, location) Fieldslib.Field.t -> unit) ->
                    unit
                  val for_all :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          bool) ->
                    location:((t, location) Fieldslib.Field.t -> bool) ->
                    bool
                  val exists :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          bool) ->
                    location:((t, location) Fieldslib.Field.t -> bool) ->
                    bool
                  val to_list :
                    name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                          'elem__) ->
                    location:((t, location) Fieldslib.Field.t -> 'elem__) ->
                    'elem__ list
                  val map_poly :
                    ([< `Read | `Set_and_create ], t, 'x0)
                    Fieldslib.Field.user -> 'x0 list
                  module Direct :
                    sig
                      val iter :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> unit) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> unit) ->
                        unit
                      val fold :
                        t ->
                        init:'acc__0 ->
                        name:('acc__0 ->
                              (t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> 'acc__1) ->
                        location:('acc__1 ->
                                  (t, location) Fieldslib.Field.t ->
                                  t -> location -> 'acc__2) ->
                        'acc__2
                      val for_all :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> bool) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> bool) ->
                        bool
                      val exists :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> bool) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> bool) ->
                        bool
                      val to_list :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t -> Trie.String.Suffix.key -> 'elem__) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> 'elem__) ->
                        'elem__ list
                      val map :
                        t ->
                        name:((t, Trie.String.Suffix.key) Fieldslib.Field.t ->
                              t ->
                              Trie.String.Suffix.key ->
                              Trie.String.Suffix.key) ->
                        location:((t, location) Fieldslib.Field.t ->
                                  t -> location -> location) ->
                        t
                      val set_all_mutable_fields : t -> unit
                    end
                end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          module Img :
            sig
              type t = {
                arch : Bap.Std.arch;
                entry : Bap.Std.addr;
                segments :
                  Bap.Std.Backend.Segment.t * Bap.Std.Backend.Segment.t list;
                symbols : Bap.Std.Backend.Symbol.t list;
                sections : Bap.Std.Backend.Section.t list;
              }
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val compare : t -> t -> int
              val sections : t -> Section.t list
              val symbols : t -> Symbol.t list
              val segments : t -> Segment.t * Segment.t list
              val entry : t -> addr
              val arch : t -> arch
              module Fields :
                sig
                  val names : Trie.String.Suffix.key list
                  val sections : (t, Section.t list) Fieldslib.Field.t
                  val symbols : (t, Symbol.t list) Fieldslib.Field.t
                  val segments :
                    (t, Segment.t * Segment.t list) Fieldslib.Field.t
                  val entry : (t, addr) Fieldslib.Field.t
                  val arch : (t, arch) Fieldslib.Field.t
                  val fold :
                    init:'acc__0 ->
                    arch:('acc__0 -> (t, arch) Fieldslib.Field.t -> 'acc__1) ->
                    entry:('acc__1 -> (t, addr) Fieldslib.Field.t -> 'acc__2) ->
                    segments:('acc__2 ->
                              (t, Segment.t * Segment.t list)
                              Fieldslib.Field.t -> 'acc__3) ->
                    symbols:('acc__3 ->
                             (t, Symbol.t list) Fieldslib.Field.t -> 'acc__4) ->
                    sections:('acc__4 ->
                              (t, Section.t list) Fieldslib.Field.t ->
                              'acc__5) ->
                    'acc__5
                  val make_creator :
                    arch:((t, arch) Fieldslib.Field.t ->
                          'acc__0 -> ('input__ -> arch) * 'acc__1) ->
                    entry:((t, addr) Fieldslib.Field.t ->
                           'acc__1 -> ('input__ -> addr) * 'acc__2) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t ->
                              'acc__2 ->
                              ('input__ -> Segment.t * Segment.t list) *
                              'acc__3) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                             'acc__3 -> ('input__ -> Symbol.t list) * 'acc__4) ->
                    sections:((t, Section.t list) Fieldslib.Field.t ->
                              'acc__4 ->
                              ('input__ -> Section.t list) * 'acc__5) ->
                    'acc__0 -> ('input__ -> t) * 'acc__5
                  val create :
                    arch:arch ->
                    entry:addr ->
                    segments:Segment.t * Segment.t list ->
                    symbols:Symbol.t list -> sections:Section.t list -> t
                  val map :
                    arch:((t, arch) Fieldslib.Field.t -> arch) ->
                    entry:((t, addr) Fieldslib.Field.t -> addr) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t -> Segment.t * Segment.t list) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                             Symbol.t list) ->
                    sections:((t, Section.t list) Fieldslib.Field.t ->
                              Section.t list) ->
                    t
                  val iter :
                    arch:((t, arch) Fieldslib.Field.t -> unit) ->
                    entry:((t, addr) Fieldslib.Field.t -> unit) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t -> unit) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t -> unit) ->
                    sections:((t, Section.t list) Fieldslib.Field.t -> unit) ->
                    unit
                  val for_all :
                    arch:((t, arch) Fieldslib.Field.t -> bool) ->
                    entry:((t, addr) Fieldslib.Field.t -> bool) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t -> bool) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t -> bool) ->
                    sections:((t, Section.t list) Fieldslib.Field.t -> bool) ->
                    bool
                  val exists :
                    arch:((t, arch) Fieldslib.Field.t -> bool) ->
                    entry:((t, addr) Fieldslib.Field.t -> bool) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t -> bool) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t -> bool) ->
                    sections:((t, Section.t list) Fieldslib.Field.t -> bool) ->
                    bool
                  val to_list :
                    arch:((t, arch) Fieldslib.Field.t -> 'elem__) ->
                    entry:((t, addr) Fieldslib.Field.t -> 'elem__) ->
                    segments:((t, Segment.t * Segment.t list)
                              Fieldslib.Field.t -> 'elem__) ->
                    symbols:((t, Symbol.t list) Fieldslib.Field.t -> 'elem__) ->
                    sections:((t, Section.t list) Fieldslib.Field.t ->
                              'elem__) ->
                    'elem__ list
                  val map_poly :
                    ([< `Read | `Set_and_create ], t, 'x0)
                    Fieldslib.Field.user -> 'x0 list
                  module Direct :
                    sig
                      val iter :
                        t ->
                        arch:((t, arch) Fieldslib.Field.t ->
                              t -> arch -> unit) ->
                        entry:((t, addr) Fieldslib.Field.t ->
                               t -> addr -> unit) ->
                        segments:((t, Segment.t * Segment.t list)
                                  Fieldslib.Field.t ->
                                  t -> Segment.t * Segment.t list -> unit) ->
                        symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                                 t -> Symbol.t list -> unit) ->
                        sections:((t, Section.t list) Fieldslib.Field.t ->
                                  t -> Section.t list -> unit) ->
                        unit
                      val fold :
                        t ->
                        init:'acc__0 ->
                        arch:('acc__0 ->
                              (t, arch) Fieldslib.Field.t ->
                              t -> arch -> 'acc__1) ->
                        entry:('acc__1 ->
                               (t, addr) Fieldslib.Field.t ->
                               t -> addr -> 'acc__2) ->
                        segments:('acc__2 ->
                                  (t, Segment.t * Segment.t list)
                                  Fieldslib.Field.t ->
                                  t -> Segment.t * Segment.t list -> 'acc__3) ->
                        symbols:('acc__3 ->
                                 (t, Symbol.t list) Fieldslib.Field.t ->
                                 t -> Symbol.t list -> 'acc__4) ->
                        sections:('acc__4 ->
                                  (t, Section.t list) Fieldslib.Field.t ->
                                  t -> Section.t list -> 'acc__5) ->
                        'acc__5
                      val for_all :
                        t ->
                        arch:((t, arch) Fieldslib.Field.t ->
                              t -> arch -> bool) ->
                        entry:((t, addr) Fieldslib.Field.t ->
                               t -> addr -> bool) ->
                        segments:((t, Segment.t * Segment.t list)
                                  Fieldslib.Field.t ->
                                  t -> Segment.t * Segment.t list -> bool) ->
                        symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                                 t -> Symbol.t list -> bool) ->
                        sections:((t, Section.t list) Fieldslib.Field.t ->
                                  t -> Section.t list -> bool) ->
                        bool
                      val exists :
                        t ->
                        arch:((t, arch) Fieldslib.Field.t ->
                              t -> arch -> bool) ->
                        entry:((t, addr) Fieldslib.Field.t ->
                               t -> addr -> bool) ->
                        segments:((t, Segment.t * Segment.t list)
                                  Fieldslib.Field.t ->
                                  t -> Segment.t * Segment.t list -> bool) ->
                        symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                                 t -> Symbol.t list -> bool) ->
                        sections:((t, Section.t list) Fieldslib.Field.t ->
                                  t -> Section.t list -> bool) ->
                        bool
                      val to_list :
                        t ->
                        arch:((t, arch) Fieldslib.Field.t ->
                              t -> arch -> 'elem__) ->
                        entry:((t, addr) Fieldslib.Field.t ->
                               t -> addr -> 'elem__) ->
                        segments:((t, Segment.t * Segment.t list)
                                  Fieldslib.Field.t ->
                                  t -> Segment.t * Segment.t list -> 'elem__) ->
                        symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                                 t -> Symbol.t list -> 'elem__) ->
                        sections:((t, Section.t list) Fieldslib.Field.t ->
                                  t -> Section.t list -> 'elem__) ->
                        'elem__ list
                      val map :
                        t ->
                        arch:((t, arch) Fieldslib.Field.t ->
                              t -> arch -> arch) ->
                        entry:((t, addr) Fieldslib.Field.t ->
                               t -> addr -> addr) ->
                        segments:((t, Segment.t * Segment.t list)
                                  Fieldslib.Field.t ->
                                  t ->
                                  Segment.t * Segment.t list ->
                                  Segment.t * Segment.t list) ->
                        symbols:((t, Symbol.t list) Fieldslib.Field.t ->
                                 t -> Symbol.t list -> Symbol.t list) ->
                        sections:((t, Section.t list) Fieldslib.Field.t ->
                                  t -> Section.t list -> Section.t list) ->
                        t
                      val set_all_mutable_fields : t -> unit
                    end
                end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
            end
          type t =
              Core_kernel.Std.Bigstring.t -> Bap.Std.Backend.Img.t option
        end
      module Image :
        sig
          type t = Bap.Std.image
          val sexp_of_t : t -> Sexplib.Sexp.t
          type segment
          val bin_segment : segment Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_segment : segment Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_segment__ :
            (int -> segment) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_segment :
            segment Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_segment : segment Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_segment :
            segment Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_segment :
            segment Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_segment : Core_kernel.Std.Bin_prot.Shape.t
          val compare_segment : segment -> segment -> int
          val segment_of_sexp : Sexplib.Sexp.t -> segment
          val sexp_of_segment : segment -> Sexplib.Sexp.t
          type symbol
          val bin_symbol : symbol Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_symbol : symbol Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_symbol__ :
            (int -> symbol) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_symbol :
            symbol Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_symbol : symbol Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_symbol : symbol Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_symbol :
            symbol Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_symbol : Core_kernel.Std.Bin_prot.Shape.t
          val compare_symbol : symbol -> symbol -> int
          val symbol_of_sexp : Sexplib.Sexp.t -> symbol
          val sexp_of_symbol : symbol -> Sexplib.Sexp.t
          type path = string
          type result =
              (Bap.Std.Image.t * Core_kernel.Std.Error.t list)
              Core_kernel.Std.Or_error.t
          val create :
            ?backend:string -> Bap.Std.Image.path -> Bap.Std.Image.result
          val of_string : ?backend:string -> string -> Bap.Std.Image.result
          val of_bigstring :
            ?backend:string ->
            Core_kernel.Std.Bigstring.t -> Bap.Std.Image.result
          val entry_point : Bap.Std.Image.t -> Bap.Std.addr
          val filename : Bap.Std.Image.t -> string option
          val arch : Bap.Std.Image.t -> Bap.Std.arch
          val addr_size : Bap.Std.Image.t -> Bap.Std.addr_size
          val endian : Bap.Std.Image.t -> Bap.Std.endian
          val words :
            Bap.Std.Image.t -> Bap.Std.size -> Bap.Std.word Bap.Std.table
          val segments :
            Bap.Std.Image.t -> Bap.Std.Image.segment Bap.Std.table
          val symbols : Bap.Std.Image.t -> Bap.Std.Image.symbol Bap.Std.table
          val segment : Bap.Std.Image.segment Bap.Std.tag
          val symbol : string Bap.Std.tag
          val section : string Bap.Std.tag
          val specification : Ogre.doc Bap.Std.tag
          val memory : Bap.Std.Image.t -> Bap.Std.value Bap.Std.memmap
          val memory_of_segment :
            Bap.Std.Image.t -> Bap.Std.Image.segment -> Bap.Std.mem
          val memory_of_symbol :
            Bap.Std.Image.t ->
            Bap.Std.Image.symbol -> Bap.Std.mem * Bap.Std.mem Bap.Std.seq
          val symbols_of_segment :
            Bap.Std.Image.t ->
            Bap.Std.Image.segment -> Bap.Std.Image.symbol Bap.Std.seq
          val segment_of_symbol :
            Bap.Std.Image.t -> Bap.Std.Image.symbol -> Bap.Std.Image.segment
          module Segment :
            sig
              type t = Bap.Std.Image.segment
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
              module Map :
                sig
                  module Key :
                    sig
                      type t = Bap.Std.Image.segment
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (Key.t, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : Key.t -> '-> 'a t
                      val of_alist :
                        (Key.t * 'a) list ->
                        [ `Duplicate_key of Key.t | `Ok of 'a t ]
                      val of_alist_or_error :
                        (Key.t * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (Key.t * 'a) list -> 'a t
                      val of_alist_multi : (Key.t * 'a) list -> 'a list t
                      val of_alist_fold :
                        (Key.t * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (Key.t * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (Key.t * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Key.t * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of Key.t | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        Key.t Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:Key.t -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:Key.t -> data:'-> 'a list t
                      val remove_multi : 'a list t -> Key.t -> 'a list t
                      val change :
                        'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> Key.t -> 'a option
                      val find_exn : 'a t -> Key.t -> 'a
                      val remove : 'a t -> Key.t -> 'a t
                      val mem : 'a t -> Key.t -> bool
                      val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:Key.t ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> Key.t list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (Key.t * 'a) list
                      val validate :
                        name:(Key.t -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (Key.t, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (Key.t * 'a) option
                      val min_elt_exn : 'a t -> Key.t * 'a
                      val max_elt : 'a t -> (Key.t * 'a) option
                      val max_elt_exn : 'a t -> Key.t * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> int
                      val split :
                        'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:Key.t Base__.Maybe_bound.t ->
                        upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:Key.t ->
                        max:Key.t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> Key.t -> (Key.t * 'a) option
                      val nth : 'a t -> int -> (Key.t * 'a) option
                      val nth_exn : 'a t -> int -> Key.t * 'a
                      val rank : 'a t -> Key.t -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:Key.t ->
                        ?keys_less_or_equal_to:Key.t ->
                        'a t -> (Key.t * 'a) Base__.Sequence.t
                      val obs :
                        Key.t Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : Key.t Bin_prot.Type_class.t
                               val bin_read_t : Key.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Key.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Key.t Bin_prot.Type_class.reader
                               val bin_size_t : Key.t Bin_prot.Size.sizer
                               val bin_write_t : Key.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Key.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Key.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = Map.Key.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (Elt.t, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(Elt.t -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(Elt.t -> bool) -> bool
                      val for_all : t -> f:(Elt.t -> bool) -> bool
                      val count : t -> f:(Elt.t -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(Elt.t -> 'sum) -> 'sum
                      val find : t -> f:(Elt.t -> bool) -> Elt.t option
                      val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                      val to_list : t -> Elt.t list
                      val to_array : t -> Elt.t array
                      val invariants : t -> bool
                      val mem : t -> Elt.t -> bool
                      val add : t -> Elt.t -> t
                      val remove : t -> Elt.t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           Elt.t ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of Elt.t * Elt.t
                           | `Left of Elt.t
                           | `Right of Elt.t ] -> unit) ->
                        unit
                      val filter : t -> f:(Elt.t -> bool) -> t
                      val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                      val elements : t -> Elt.t list
                      val min_elt : t -> Elt.t option
                      val min_elt_exn : t -> Elt.t
                      val max_elt : t -> Elt.t option
                      val max_elt_exn : t -> Elt.t
                      val choose : t -> Elt.t option
                      val choose_exn : t -> Elt.t
                      val split : t -> Elt.t -> t * Elt.t option * t
                      val group_by :
                        t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                      val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                      val find_index : t -> int -> Elt.t option
                      val nth : t -> int -> Elt.t option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t -> Elt.t Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t ->
                        t ->
                        (Elt.t, Elt.t)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(Elt.t -> 'data) ->
                        (Elt.t, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        Elt.t Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : Elt.t -> t
                      val union_list : t list -> t
                      val of_list : Elt.t list -> t
                      val of_array : Elt.t array -> t
                      val of_sorted_array :
                        Elt.t array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : Elt.t array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Elt.t) -> t
                      val stable_dedup_list : Elt.t list -> Elt.t list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t option) -> t
                      val of_tree : t -> t
                      val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (Elt.t, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        Elt.t Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (Elt.t, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : Elt.t Bin_prot.Type_class.t
                               val bin_read_t : Elt.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Elt.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Elt.t Bin_prot.Type_class.reader
                               val bin_size_t : Elt.t Bin_prot.Size.sizer
                               val bin_write_t : Elt.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Elt.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Elt.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              val hash : t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Value.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = Hash_set.elt
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> Key.t -> 'a
                  val enqueue :
                    'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> Key.t Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> Key.t * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
                  val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                end
              type info =
                  Trie.String.Suffix.key *
                  [ `Ver of Trie.String.Suffix.key ] *
                  Trie.String.Suffix.key option
              val version : Trie.String.Suffix.key
              val size_in_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> int
              val of_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
              val to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
              val blit_to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Regular.Std.bytes -> t -> int -> unit
              val of_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
              val to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
              val blit_to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.bigstring -> t -> int -> unit
              module Io :
                sig
                  val read :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t
                  val load :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.In_channel.t -> t
                  val load_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
                  val scan :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.In_channel.t -> unit -> t option
                  val write :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t -> unit
                  val save :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t -> t -> unit
                  val save_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t -> t list -> unit
                  val dump :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t ->
                    (unit -> t option) -> unit
                  val show :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key -> t -> unit
                  val print :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Format.formatter -> t -> unit
                end
              module Cache :
                sig
                  val load : Regular.Std.digest -> t option
                  val save : Regular.Std.digest -> t -> unit
                end
              val add_reader :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader -> unit
              val add_writer :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer -> unit
              val available_readers : unit -> info list
              val default_reader : unit -> info
              val set_default_reader :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val available_writers : unit -> info list
              val default_writer : unit -> info
              val set_default_writer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val default_printer : unit -> info option
              val set_default_printer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_printer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val find_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader option
              val find_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer option
              val name : Bap.Std.Image.Segment.t -> string
              val is_writable : Bap.Std.Image.Segment.t -> bool
              val is_readable : Bap.Std.Image.Segment.t -> bool
              val is_executable : Bap.Std.Image.Segment.t -> bool
            end
          module Symbol :
            sig
              type t = Bap.Std.Image.symbol
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
              module Map :
                sig
                  module Key :
                    sig
                      type t = Bap.Std.Image.symbol
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (Key.t, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : Key.t -> '-> 'a t
                      val of_alist :
                        (Key.t * 'a) list ->
                        [ `Duplicate_key of Key.t | `Ok of 'a t ]
                      val of_alist_or_error :
                        (Key.t * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (Key.t * 'a) list -> 'a t
                      val of_alist_multi : (Key.t * 'a) list -> 'a list t
                      val of_alist_fold :
                        (Key.t * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (Key.t * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (Key.t * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Key.t * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of Key.t | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        Key.t Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:Key.t -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:Key.t -> data:'-> 'a list t
                      val remove_multi : 'a list t -> Key.t -> 'a list t
                      val change :
                        'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> Key.t -> 'a option
                      val find_exn : 'a t -> Key.t -> 'a
                      val remove : 'a t -> Key.t -> 'a t
                      val mem : 'a t -> Key.t -> bool
                      val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:Key.t ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> Key.t list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (Key.t * 'a) list
                      val validate :
                        name:(Key.t -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (Key.t, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (Key.t * 'a) option
                      val min_elt_exn : 'a t -> Key.t * 'a
                      val max_elt : 'a t -> (Key.t * 'a) option
                      val max_elt_exn : 'a t -> Key.t * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> int
                      val split :
                        'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:Key.t Base__.Maybe_bound.t ->
                        upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:Key.t ->
                        max:Key.t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> Key.t -> (Key.t * 'a) option
                      val nth : 'a t -> int -> (Key.t * 'a) option
                      val nth_exn : 'a t -> int -> Key.t * 'a
                      val rank : 'a t -> Key.t -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:Key.t ->
                        ?keys_less_or_equal_to:Key.t ->
                        'a t -> (Key.t * 'a) Base__.Sequence.t
                      val obs :
                        Key.t Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : Key.t Bin_prot.Type_class.t
                               val bin_read_t : Key.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Key.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Key.t Bin_prot.Type_class.reader
                               val bin_size_t : Key.t Bin_prot.Size.sizer
                               val bin_write_t : Key.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Key.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Key.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = Map.Key.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (Elt.t, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(Elt.t -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(Elt.t -> bool) -> bool
                      val for_all : t -> f:(Elt.t -> bool) -> bool
                      val count : t -> f:(Elt.t -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(Elt.t -> 'sum) -> 'sum
                      val find : t -> f:(Elt.t -> bool) -> Elt.t option
                      val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                      val to_list : t -> Elt.t list
                      val to_array : t -> Elt.t array
                      val invariants : t -> bool
                      val mem : t -> Elt.t -> bool
                      val add : t -> Elt.t -> t
                      val remove : t -> Elt.t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           Elt.t ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of Elt.t * Elt.t
                           | `Left of Elt.t
                           | `Right of Elt.t ] -> unit) ->
                        unit
                      val filter : t -> f:(Elt.t -> bool) -> t
                      val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                      val elements : t -> Elt.t list
                      val min_elt : t -> Elt.t option
                      val min_elt_exn : t -> Elt.t
                      val max_elt : t -> Elt.t option
                      val max_elt_exn : t -> Elt.t
                      val choose : t -> Elt.t option
                      val choose_exn : t -> Elt.t
                      val split : t -> Elt.t -> t * Elt.t option * t
                      val group_by :
                        t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                      val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                      val find_index : t -> int -> Elt.t option
                      val nth : t -> int -> Elt.t option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t -> Elt.t Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t ->
                        t ->
                        (Elt.t, Elt.t)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(Elt.t -> 'data) ->
                        (Elt.t, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        Elt.t Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : Elt.t -> t
                      val union_list : t list -> t
                      val of_list : Elt.t list -> t
                      val of_array : Elt.t array -> t
                      val of_sorted_array :
                        Elt.t array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : Elt.t array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Elt.t) -> t
                      val stable_dedup_list : Elt.t list -> Elt.t list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t option) -> t
                      val of_tree : t -> t
                      val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (Elt.t, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        Elt.t Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (Elt.t, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : Elt.t Bin_prot.Type_class.t
                               val bin_read_t : Elt.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Elt.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Elt.t Bin_prot.Type_class.reader
                               val bin_size_t : Elt.t Bin_prot.Size.sizer
                               val bin_write_t : Elt.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Elt.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Elt.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              val hash : t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Segment.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = Hash_set.elt
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> Key.t -> 'a
                  val enqueue :
                    'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> Key.t Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> Key.t * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
                  val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                end
              type info =
                  Trie.String.Suffix.key *
                  [ `Ver of Trie.String.Suffix.key ] *
                  Trie.String.Suffix.key option
              val version : Trie.String.Suffix.key
              val size_in_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> int
              val of_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
              val to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
              val blit_to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Regular.Std.bytes -> t -> int -> unit
              val of_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
              val to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
              val blit_to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.bigstring -> t -> int -> unit
              module Io :
                sig
                  val read :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t
                  val load :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.In_channel.t -> t
                  val load_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
                  val scan :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.In_channel.t -> unit -> t option
                  val write :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t -> unit
                  val save :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t -> t -> unit
                  val save_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t -> t list -> unit
                  val dump :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t ->
                    (unit -> t option) -> unit
                  val show :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key -> t -> unit
                  val print :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Format.formatter -> t -> unit
                end
              module Cache :
                sig
                  val load : Regular.Std.digest -> t option
                  val save : Regular.Std.digest -> t -> unit
                end
              val add_reader :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader -> unit
              val add_writer :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer -> unit
              val available_readers : unit -> info list
              val default_reader : unit -> info
              val set_default_reader :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val available_writers : unit -> info list
              val default_writer : unit -> info
              val set_default_writer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val default_printer : unit -> info option
              val set_default_printer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_printer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val find_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader option
              val find_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer option
              val name : Bap.Std.Image.Symbol.t -> string
              val is_function : Bap.Std.Image.Symbol.t -> bool
              val is_debug : Bap.Std.Image.Symbol.t -> bool
            end
          module type Loader =
            sig
              val from_file :
                string -> Ogre.doc option Core_kernel.Std.Or_error.t
              val from_data :
                Core_kernel.Std.Bigstring.t ->
                Ogre.doc option Core_kernel.Std.Or_error.t
            end
          val register_loader :
            name:string -> (module Bap.Std.Image.Loader-> unit
          val available_backends : unit -> string list
          val register_backend :
            name:string -> Bap.Std.Backend.t -> [ `Duplicate | `Ok ]
          val data : Bap.Std.Image.t -> Core_kernel.Std.Bigstring.t
          val spec : Bap.Std.Image.t -> Ogre.doc
          module Scheme :
            sig
              type addr = int64
              type size = int64
              type off = int64
              type 'a region = {
                addr : Bap.Std.Image.Scheme.addr;
                size : Bap.Std.Image.Scheme.size;
                info : 'a;
              }
              val off : Bap.Std.Image.Scheme.off Ogre.field
              val size : Bap.Std.Image.Scheme.size Ogre.field
              val addr : Bap.Std.Image.Scheme.addr Ogre.field
              val name : string Ogre.field
              val root : Bap.Std.Image.Scheme.addr Ogre.field
              val readable : bool Ogre.field
              val writable : bool Ogre.field
              val executable : bool Ogre.field
              val fixup : Bap.Std.Image.Scheme.addr Ogre.field
              val arch : (string, (string -> 'a) -> 'a) Ogre.attribute
              val segment :
                ((bool * bool * bool) Bap.Std.Image.Scheme.region,
                 (Bap.Std.Image.Scheme.addr ->
                  Bap.Std.Image.Scheme.size -> bool -> bool -> bool -> 'a) ->
                 'a)
                Ogre.attribute
              val section :
                (unit Bap.Std.Image.Scheme.region,
                 (Bap.Std.Image.Scheme.addr ->
                  Bap.Std.Image.Scheme.size -> 'a) ->
                 'a)
                Ogre.attribute
              val code_start :
                (Bap.Std.Image.Scheme.addr,
                 (Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
                Ogre.attribute
              val entry_point :
                (Bap.Std.Image.Scheme.addr,
                 (Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
                Ogre.attribute
              val symbol_chunk :
                (Bap.Std.Image.Scheme.addr Bap.Std.Image.Scheme.region,
                 (Bap.Std.Image.Scheme.addr ->
                  Bap.Std.Image.Scheme.size ->
                  Bap.Std.Image.Scheme.addr -> 'a) ->
                 'a)
                Ogre.attribute
              val named_region :
                (string Bap.Std.Image.Scheme.region,
                 (Bap.Std.Image.Scheme.addr ->
                  Bap.Std.Image.Scheme.size -> string -> 'a) ->
                 'a)
                Ogre.attribute
              val named_symbol :
                (Bap.Std.Image.Scheme.addr * string,
                 (Bap.Std.Image.Scheme.addr -> string -> 'a) -> 'a)
                Ogre.attribute
              val mapped :
                (Bap.Std.Image.Scheme.off Bap.Std.Image.Scheme.region,
                 (Bap.Std.Image.Scheme.addr ->
                  Bap.Std.Image.Scheme.size -> Bap.Std.Image.Scheme.off -> 'a) ->
                 'a)
                Ogre.attribute
              val relocation :
                (int64 * Bap.Std.Image.Scheme.addr,
                 (Bap.Std.Image.Scheme.addr ->
                  Bap.Std.Image.Scheme.addr -> 'a) ->
                 'a)
                Ogre.attribute
              val external_reference :
                (Bap.Std.Image.Scheme.addr * string,
                 (Bap.Std.Image.Scheme.addr -> string -> 'a) -> 'a)
                Ogre.attribute
              val base_address :
                (Bap.Std.Image.Scheme.addr,
                 (Bap.Std.Image.Scheme.addr -> 'a) -> 'a)
                Ogre.attribute
            end
        end
      module Memmap :
        sig
          type 'a t = 'Bap.Std.memmap
          val sexp_of_t : ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
          val empty : 'Bap.Std.Memmap.t
          val singleton : Bap.Std.mem -> '-> 'Bap.Std.Memmap.t
          val min_addr : 'Bap.Std.Memmap.t -> Bap.Std.addr option
          val max_addr : 'Bap.Std.Memmap.t -> Bap.Std.addr option
          val min_binding : 'Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) option
          val max_binding : 'Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) option
          val add :
            'Bap.Std.Memmap.t -> Bap.Std.mem -> '-> 'Bap.Std.Memmap.t
          val dominators :
            'Bap.Std.Memmap.t ->
            Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
          val intersections :
            'Bap.Std.Memmap.t ->
            Bap.Std.mem -> (Bap.Std.mem * 'a) Bap.Std.seq
          val intersects : 'Bap.Std.Memmap.t -> Bap.Std.mem -> bool
          val dominates : 'Bap.Std.Memmap.t -> Bap.Std.mem -> bool
          val contains : 'Bap.Std.Memmap.t -> Bap.Std.addr -> bool
          val lookup :
            'Bap.Std.Memmap.t ->
            Bap.Std.addr -> (Bap.Std.mem * 'a) Bap.Std.seq
          val map :
            'Bap.Std.Memmap.t -> f:('-> 'b) -> 'Bap.Std.Memmap.t
          val mapi :
            'Bap.Std.Memmap.t ->
            f:(Bap.Std.mem -> '-> 'b) -> 'Bap.Std.Memmap.t
          val filter :
            'Bap.Std.Memmap.t -> f:('-> bool) -> 'Bap.Std.Memmap.t
          val filter_map :
            'Bap.Std.Memmap.t -> f:('-> 'b option) -> 'Bap.Std.Memmap.t
          val filter_mapi :
            'Bap.Std.Memmap.t ->
            f:(Bap.Std.mem -> '-> 'b option) -> 'Bap.Std.Memmap.t
          val remove :
            'Bap.Std.Memmap.t -> Bap.Std.mem -> 'Bap.Std.Memmap.t
          val remove_intersections :
            'Bap.Std.Memmap.t -> Bap.Std.mem -> 'Bap.Std.Memmap.t
          val remove_dominators :
            'Bap.Std.Memmap.t -> Bap.Std.mem -> 'Bap.Std.Memmap.t
          val to_sequence :
            'Bap.Std.Memmap.t -> (Bap.Std.mem * 'a) Bap.Std.seq
          val mem : 'a t -> '-> equal:('-> '-> bool) -> bool
          val length : 'a t -> int
          val is_empty : 'a t -> bool
          val iter : 'a t -> f:('-> unit) -> unit
          val fold :
            'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
          val fold_result :
            'a t ->
            init:'accum ->
            f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
            ('accum, 'e) Base__.Result.t
          val fold_until :
            'a t ->
            init:'accum ->
            f:('accum ->
               '-> ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
            ('accum, 'stop) Base.Container_intf.Finished_or_stopped_early.t
          val exists : 'a t -> f:('-> bool) -> bool
          val for_all : 'a t -> f:('-> bool) -> bool
          val count : 'a t -> f:('-> bool) -> int
          val sum :
            (module Base__.Commutative_group.S with type t = 'sum) ->
            'a t -> f:('-> 'sum) -> 'sum
          val find : 'a t -> f:('-> bool) -> 'a option
          val find_map : 'a t -> f:('-> 'b option) -> 'b option
          val to_list : 'a t -> 'a list
          val to_array : 'a t -> 'a array
          val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
          val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
          val pp :
            'Regular.Std.printer -> 'Bap.Std.Memmap.t Regular.Std.printer
        end
      type symbolizer
      type rooter
      type brancher
      type reconstructor
      type disasm
      type insn
      val bin_insn : insn Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_insn : insn Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_insn__ :
        (int -> insn) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_insn : insn Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_insn : insn Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_insn : insn Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_insn : insn Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_insn : Core_kernel.Std.Bin_prot.Shape.t
      val compare_insn : insn -> insn -> int
      val sexp_of_insn : insn -> Sexplib.Sexp.t
      type block
      val compare_block : block -> block -> int
      val sexp_of_block : block -> Sexplib.Sexp.t
      type cfg
      val compare_cfg : cfg -> cfg -> int
      type jump = [ `Cond | `Jump ]
      val compare_jump : jump -> jump -> int
      val jump_of_sexp : Sexplib.Sexp.t -> jump
      val __jump_of_sexp__ : Sexplib.Sexp.t -> jump
      val sexp_of_jump : jump -> Sexplib.Sexp.t
      type edge = [ `Cond | `Fall | `Jump ]
      val compare_edge : edge -> edge -> int
      val edge_of_sexp : Sexplib.Sexp.t -> edge
      val __edge_of_sexp__ : Sexplib.Sexp.t -> edge
      val sexp_of_edge : edge -> Sexplib.Sexp.t
      module Kind :
        sig
          type branch =
              [ `Conditional_branch
              | `Indirect_branch
              | `Unconditional_branch ]
          val bin_branch : branch Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_branch : branch Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_branch__ :
            (int -> branch) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_branch :
            branch Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_branch : branch Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_branch : branch Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_branch :
            branch Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_branch : Core_kernel.Std.Bin_prot.Shape.t
          val compare_branch : branch -> branch -> int
          val all_of_branch : branch list
          val branch_of_sexp : Sexplib.Sexp.t -> branch
          val __branch_of_sexp__ : Sexplib.Sexp.t -> branch
          val sexp_of_branch : branch -> Sexplib.Sexp.t
          type affecting_control =
              [ `Barrier
              | `Call
              | `Conditional_branch
              | `Indirect_branch
              | `May_affect_control_flow
              | `Return
              | `Terminator
              | `Unconditional_branch ]
          val bin_affecting_control :
            affecting_control Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_affecting_control :
            affecting_control Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_affecting_control__ :
            (int -> affecting_control) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_affecting_control :
            affecting_control Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_affecting_control :
            affecting_control Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_affecting_control :
            affecting_control Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_affecting_control :
            affecting_control Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_affecting_control : Core_kernel.Std.Bin_prot.Shape.t
          val compare_affecting_control :
            affecting_control -> affecting_control -> int
          val all_of_affecting_control : affecting_control list
          val affecting_control_of_sexp : Sexplib.Sexp.t -> affecting_control
          val __affecting_control_of_sexp__ :
            Sexplib.Sexp.t -> affecting_control
          val sexp_of_affecting_control : affecting_control -> Sexplib.Sexp.t
          type having_side_effect = [ `May_load | `May_store ]
          val bin_having_side_effect :
            having_side_effect Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_having_side_effect :
            having_side_effect Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_having_side_effect__ :
            (int -> having_side_effect) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_having_side_effect :
            having_side_effect Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_having_side_effect :
            having_side_effect Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_having_side_effect :
            having_side_effect Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_having_side_effect :
            having_side_effect Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_having_side_effect : Core_kernel.Std.Bin_prot.Shape.t
          val compare_having_side_effect :
            having_side_effect -> having_side_effect -> int
          val all_of_having_side_effect : having_side_effect list
          val having_side_effect_of_sexp :
            Sexplib.Sexp.t -> having_side_effect
          val __having_side_effect_of_sexp__ :
            Sexplib.Sexp.t -> having_side_effect
          val sexp_of_having_side_effect :
            having_side_effect -> Sexplib.Sexp.t
          type t =
              [ `Barrier
              | `Call
              | `Conditional_branch
              | `Indirect_branch
              | `May_affect_control_flow
              | `May_load
              | `May_store
              | `Return
              | `Terminator
              | `Unconditional_branch ]
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val compare : t -> t -> int
          val all : t list
          val t_of_sexp : Sexplib.Sexp.t -> t
          val __t_of_sexp__ : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
        end
      type reg
      val bin_reg : reg Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_reg : reg Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_reg__ :
        (int -> reg) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_reg : reg Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_reg : reg Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_reg : reg Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_reg : reg Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_reg : Core_kernel.Std.Bin_prot.Shape.t
      val compare_reg : reg -> reg -> int
      val reg_of_sexp : Sexplib.Sexp.t -> reg
      val sexp_of_reg : reg -> Sexplib.Sexp.t
      type imm
      val bin_imm : imm Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_imm : imm Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_imm__ :
        (int -> imm) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_imm : imm Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_imm : imm Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_imm : imm Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_imm : imm Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_imm : Core_kernel.Std.Bin_prot.Shape.t
      val compare_imm : imm -> imm -> int
      val imm_of_sexp : Sexplib.Sexp.t -> imm
      val sexp_of_imm : imm -> Sexplib.Sexp.t
      type fmm
      val bin_fmm : fmm Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_fmm : fmm Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_fmm__ :
        (int -> fmm) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_fmm : fmm Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_fmm : fmm Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_fmm : fmm Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_fmm : fmm Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_fmm : Core_kernel.Std.Bin_prot.Shape.t
      val compare_fmm : fmm -> fmm -> int
      val fmm_of_sexp : Sexplib.Sexp.t -> fmm
      val sexp_of_fmm : fmm -> Sexplib.Sexp.t
      type kind = Bap.Std.Kind.t
      val bin_kind : kind Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_kind : kind Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_kind__ :
        (int -> kind) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_kind : kind Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_kind : kind Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_kind : kind Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_kind : kind Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_kind : Core_kernel.Std.Bin_prot.Shape.t
      val compare_kind : kind -> kind -> int
      val kind_of_sexp : Sexplib.Sexp.t -> kind
      val sexp_of_kind : kind -> Sexplib.Sexp.t
      module Reg :
        sig
          type t = Bap.Std.reg
          val code : Bap.Std.Reg.t -> int
          val name : Bap.Std.Reg.t -> string
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.reg
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Value.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Imm :
        sig
          type t = Bap.Std.imm
          val to_word : Bap.Std.Imm.t -> width:int -> Bap.Std.word option
          val to_int64 : Bap.Std.Imm.t -> int64
          val to_int : Bap.Std.Imm.t -> int option
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.imm
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Reg.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Fmm :
        sig
          type t = Bap.Std.fmm
          val to_float : Bap.Std.Fmm.t -> float
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.fmm
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Imm.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Op :
        sig
          type t =
              Reg of Bap.Std.reg
            | Imm of Bap.Std.imm
            | Fmm of Bap.Std.fmm
          module Normalized :
            sig
              val compare : Bap.Std.Op.t -> Bap.Std.Op.t -> int
              val hash : Bap.Std.Op.t -> int
              val compare_ops :
                Bap.Std.Op.t array -> Bap.Std.Op.t array -> int
            end
          val pp_adt : Format.formatter -> Bap.Std.Op.t -> unit
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Fmm.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      type op = Bap.Std.Op.t
      val bin_op : op Core_kernel.Std.Bin_prot.Type_class.t
      val bin_read_op : op Core_kernel.Std.Bin_prot.Read.reader
      val __bin_read_op__ : (int -> op) Core_kernel.Std.Bin_prot.Read.reader
      val bin_reader_op : op Core_kernel.Std.Bin_prot.Type_class.reader
      val bin_size_op : op Core_kernel.Std.Bin_prot.Size.sizer
      val bin_write_op : op Core_kernel.Std.Bin_prot.Write.writer
      val bin_writer_op : op Core_kernel.Std.Bin_prot.Type_class.writer
      val bin_shape_op : Core_kernel.Std.Bin_prot.Shape.t
      val compare_op : op -> op -> int
      val sexp_of_op : op -> Sexplib.Sexp.t
      module Disasm_expert :
        sig
          module Basic :
            sig
              type pred =
                  [ `Barrier
                  | `Call
                  | `Conditional_branch
                  | `Indirect_branch
                  | `May_affect_control_flow
                  | `May_load
                  | `May_store
                  | `Return
                  | `Terminator
                  | `Unconditional_branch
                  | `Valid ]
              val pred_of_sexp : Sexplib.Sexp.t -> pred
              val __pred_of_sexp__ : Sexplib.Sexp.t -> pred
              val sexp_of_pred : pred -> Sexplib.Sexp.t
              type (+'a, +'k) insn
              type ('a, 'k) insns =
                  (Bap.Std.mem *
                   ('a, 'k) Bap.Std.Disasm_expert.Basic.insn option)
                  list
              type empty
              type asm
              type kinds
              type full_insn =
                  (Bap.Std.Disasm_expert.Basic.asm,
                   Bap.Std.Disasm_expert.Basic.kinds)
                  Bap.Std.Disasm_expert.Basic.insn
              val compare_full_insn : full_insn -> full_insn -> int
              val sexp_of_full_insn : full_insn -> Sexplib.Sexp.t
              type ('a, 'k) t
              type (+'a, +'k, 's, 'r) state
              val with_disasm :
                ?debug_level:int ->
                ?cpu:string ->
                backend:string ->
                string ->
                f:((Bap.Std.Disasm_expert.Basic.empty,
                    Bap.Std.Disasm_expert.Basic.empty)
                   Bap.Std.Disasm_expert.Basic.t ->
                   'Core_kernel.Std.Or_error.t) ->
                'Core_kernel.Std.Or_error.t
              val create :
                ?debug_level:int ->
                ?cpu:string ->
                backend:string ->
                string ->
                (Bap.Std.Disasm_expert.Basic.empty,
                 Bap.Std.Disasm_expert.Basic.empty)
                Bap.Std.Disasm_expert.Basic.t Core_kernel.Std.Or_error.t
              val close : ('a, 'b) Bap.Std.Disasm_expert.Basic.t -> unit
              val store_asm :
                ('a, 'k) Bap.Std.Disasm_expert.Basic.t ->
                (Bap.Std.Disasm_expert.Basic.asm, 'k)
                Bap.Std.Disasm_expert.Basic.t
              val store_kinds :
                ('a, 'b) Bap.Std.Disasm_expert.Basic.t ->
                ('a, Bap.Std.Disasm_expert.Basic.kinds)
                Bap.Std.Disasm_expert.Basic.t
              val run :
                ?backlog:int ->
                ?stop_on:Bap.Std.Disasm_expert.Basic.pred list ->
                ?invalid:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                          Bap.Std.mem -> '-> 'r) ->
                ?stopped:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                          '-> 'r) ->
                ?hit:(('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                      Bap.Std.mem ->
                      (Bap.Std.Disasm_expert.Basic.asm,
                       Bap.Std.Disasm_expert.Basic.kinds)
                      Bap.Std.Disasm_expert.Basic.insn -> '-> 'r) ->
                ('a, 'k) Bap.Std.Disasm_expert.Basic.t ->
                return:('-> 'r) -> init:'-> Bap.Std.mem -> 'r
              val insn_of_mem :
                ('a, 'b) Bap.Std.Disasm_expert.Basic.t ->
                Bap.Std.mem ->
                (Bap.Std.mem *
                 (Bap.Std.Disasm_expert.Basic.asm,
                  Bap.Std.Disasm_expert.Basic.kinds)
                 Bap.Std.Disasm_expert.Basic.insn option *
                 [ `finished | `left of Bap.Std.mem ])
                Core_kernel.Std.Or_error.t
              val addr :
                ('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
                Bap.Std.addr
              val preds :
                ('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
                Bap.Std.Disasm_expert.Basic.pred list
              val with_preds :
                ('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                Bap.Std.Disasm_expert.Basic.pred list ->
                ('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state
              val insns :
                ('a, 'k, 'b, 'c) Bap.Std.Disasm_expert.Basic.state ->
                ('a, 'k) Bap.Std.Disasm_expert.Basic.insns
              val last :
                ('a, 'k, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                int -> ('a, 'k) Bap.Std.Disasm_expert.Basic.insns
              val memory :
                ('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
                Bap.Std.mem
              val stop :
                ('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                '-> 'r
              val step :
                ('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                '-> 'r
              val jump :
                ('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                Bap.Std.mem -> '-> 'r
              val back :
                ('a, 'b, 's, 'r) Bap.Std.Disasm_expert.Basic.state ->
                '-> 'r
              module Insn :
                sig
                  type ('a, 'k) t = ('a, 'k) Bap.Std.Disasm_expert.Basic.insn
                  val sexp_of_t :
                    ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
                    Core_kernel.Std.Sexp.t
                  val compare :
                    ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
                    ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> int
                  val code :
                    ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> int
                  val name :
                    ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t -> string
                  val kinds :
                    ('a, Bap.Std.Disasm_expert.Basic.kinds)
                    Bap.Std.Disasm_expert.Basic.Insn.t -> Bap.Std.Kind.t list
                  val is :
                    ('a, Bap.Std.Disasm_expert.Basic.kinds)
                    Bap.Std.Disasm_expert.Basic.Insn.t ->
                    Bap.Std.Kind.t -> bool
                  val asm :
                    (Bap.Std.Disasm_expert.Basic.asm, 'k)
                    Bap.Std.Disasm_expert.Basic.Insn.t -> string
                  val ops :
                    ('a, 'k) Bap.Std.Disasm_expert.Basic.Insn.t ->
                    Bap.Std.op array
                end
              module Trie :
                sig
                  type key
                  val key_of_first_insns :
                    ('a, 'b, 'c, 'd) Bap.Std.Disasm_expert.Basic.state ->
                    len:int -> Bap.Std.Disasm_expert.Basic.Trie.key option
                  module Normalized :
                    sig
                      type 'a t
                      val bin_t :
                        'Core_kernel.Std.Bin_prot.Type_class.t ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.t
                      val bin_read_t :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        'a t Core_kernel.Std.Bin_prot.Read.reader
                      val __bin_read_t__ :
                        'Core_kernel.Std.Bin_prot.Read.reader ->
                        (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                      val bin_reader_t :
                        'Core_kernel.Std.Bin_prot.Type_class.reader ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.reader
                      val bin_size_t :
                        'Core_kernel.Std.Bin_prot.Size.sizer ->
                        'a t Core_kernel.Std.Bin_prot.Size.sizer
                      val bin_write_t :
                        'Core_kernel.Std.Bin_prot.Write.writer ->
                        'a t Core_kernel.Std.Bin_prot.Write.writer
                      val bin_writer_t :
                        'Core_kernel.Std.Bin_prot.Type_class.writer ->
                        'a t Core_kernel.Std.Bin_prot.Type_class.writer
                      val bin_shape_t :
                        Core_kernel.Std.Bin_prot.Shape.t ->
                        Core_kernel.Std.Bin_prot.Shape.t
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      type key = key
                      val create : unit -> 'a t
                      val add : 'a t -> key:key -> data:'-> unit
                      val change :
                        'a t -> key -> ('a option -> 'a option) -> unit
                      val find : 'a t -> key -> 'a option
                      val walk :
                        'a t ->
                        key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                      val remove : 'a t -> key -> unit
                      val longest_match : 'a t -> key -> (int * 'a) option
                      val length : 'a t -> int
                      val pp :
                        'Regular.Std.printer -> 'a t Regular.Std.printer
                    end
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              val available_backends : unit -> string list
            end
          module Linear :
            sig
              type t = (Bap.Std.mem * Bap.Std.insn option) list
              val sweep :
                ?backend:string ->
                Bap.Std.arch ->
                Bap.Std.mem ->
                Bap.Std.Disasm_expert.Linear.t Core_kernel.Std.Or_error.t
              module With_exn :
                sig
                  val sweep :
                    ?backend:string ->
                    Bap.Std.arch ->
                    Bap.Std.mem -> Bap.Std.Disasm_expert.Linear.t
                end
            end
          module Recursive :
            sig
              type t
              type error =
                  [ `Failed_to_disasm of Bap.Std.mem
                  | `Failed_to_lift of
                      Bap.Std.mem * Bap.Std.Disasm_expert.Basic.full_insn *
                      Core_kernel.Std.Error.t ]
              val sexp_of_error : error -> Sexplib.Sexp.t
              val run :
                ?backend:string ->
                ?brancher:Bap.Std.brancher ->
                ?rooter:Bap.Std.rooter ->
                Bap.Std.arch ->
                Bap.Std.mem ->
                Bap.Std.Disasm_expert.Recursive.t Core_kernel.Std.Or_error.t
              val cfg : Bap.Std.Disasm_expert.Recursive.t -> Bap.Std.cfg
              val errors :
                Bap.Std.Disasm_expert.Recursive.t ->
                Bap.Std.Disasm_expert.Recursive.error list
            end
        end
      module Insn :
        sig
          type t = Bap.Std.insn
          val of_basic :
            ?bil:Bap.Std.bil ->
            Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Insn.t
          val name : Bap.Std.Insn.t -> string
          val asm : Bap.Std.Insn.t -> string
          val bil : Bap.Std.Insn.t -> Bap.Std.bil
          val ops : Bap.Std.Insn.t -> Bap.Std.op array
          type must = Must
          type may = May
          type 'a property
          val new_property : '-> string -> 'Bap.Std.Insn.property
          val jump : Bap.Std.Insn.must Bap.Std.Insn.property
          val conditional : Bap.Std.Insn.must Bap.Std.Insn.property
          val indirect : Bap.Std.Insn.must Bap.Std.Insn.property
          val call : Bap.Std.Insn.must Bap.Std.Insn.property
          val return : Bap.Std.Insn.must Bap.Std.Insn.property
          val affect_control_flow : Bap.Std.Insn.may Bap.Std.Insn.property
          val load : Bap.Std.Insn.may Bap.Std.Insn.property
          val store : Bap.Std.Insn.may Bap.Std.Insn.property
          val is :
            Bap.Std.Insn.must Bap.Std.Insn.property -> Bap.Std.Insn.t -> bool
          val may :
            Bap.Std.Insn.may Bap.Std.Insn.property -> Bap.Std.Insn.t -> bool
          val must :
            Bap.Std.Insn.must Bap.Std.Insn.property ->
            Bap.Std.Insn.t -> Bap.Std.Insn.t
          val mustn't :
            Bap.Std.Insn.must Bap.Std.Insn.property ->
            Bap.Std.Insn.t -> Bap.Std.Insn.t
          val should :
            Bap.Std.Insn.may Bap.Std.Insn.property ->
            Bap.Std.Insn.t -> Bap.Std.Insn.t
          val shouldn't :
            Bap.Std.Insn.may Bap.Std.Insn.property ->
            Bap.Std.Insn.t -> Bap.Std.Insn.t
          val pp_adt : Bap.Std.Insn.t Regular.Std.printer
          module Trie :
            sig
              type key
              val key_of_insns : Bap.Std.Insn.t list -> Bap.Std.Insn.Trie.key
              module Normalized :
                sig
                  type 'a t
                  val bin_t :
                    'Core_kernel.Std.Bin_prot.Type_class.t ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.t
                  val bin_read_t :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    'a t Core_kernel.Std.Bin_prot.Read.reader
                  val __bin_read_t__ :
                    'Core_kernel.Std.Bin_prot.Read.reader ->
                    (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
                  val bin_reader_t :
                    'Core_kernel.Std.Bin_prot.Type_class.reader ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.reader
                  val bin_size_t :
                    'Core_kernel.Std.Bin_prot.Size.sizer ->
                    'a t Core_kernel.Std.Bin_prot.Size.sizer
                  val bin_write_t :
                    'Core_kernel.Std.Bin_prot.Write.writer ->
                    'a t Core_kernel.Std.Bin_prot.Write.writer
                  val bin_writer_t :
                    'Core_kernel.Std.Bin_prot.Type_class.writer ->
                    'a t Core_kernel.Std.Bin_prot.Type_class.writer
                  val bin_shape_t :
                    Core_kernel.Std.Bin_prot.Shape.t ->
                    Core_kernel.Std.Bin_prot.Shape.t
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  type key = key
                  val create : unit -> 'a t
                  val add : 'a t -> key:key -> data:'-> unit
                  val change :
                    'a t -> key -> ('a option -> 'a option) -> unit
                  val find : 'a t -> key -> 'a option
                  val walk :
                    'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
                  val remove : 'a t -> key -> unit
                  val longest_match : 'a t -> key -> (int * 'a) option
                  val length : 'a t -> int
                  val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
                end
              type 'a t
              val bin_t :
                'Core_kernel.Std.Bin_prot.Type_class.t ->
                'a t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t :
                'Core_kernel.Std.Bin_prot.Read.reader ->
                'a t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                'Core_kernel.Std.Bin_prot.Read.reader ->
                (int -> 'a t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t :
                'Core_kernel.Std.Bin_prot.Type_class.reader ->
                'a t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t :
                'Core_kernel.Std.Bin_prot.Size.sizer ->
                'a t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t :
                'Core_kernel.Std.Bin_prot.Write.writer ->
                'a t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t :
                'Core_kernel.Std.Bin_prot.Type_class.writer ->
                'a t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t :
                Core_kernel.Std.Bin_prot.Shape.t ->
                Core_kernel.Std.Bin_prot.Shape.t
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'a) -> Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val create : unit -> 'a t
              val add : 'a t -> key:key -> data:'-> unit
              val change : 'a t -> key -> ('a option -> 'a option) -> unit
              val find : 'a t -> key -> 'a option
              val walk :
                'a t -> key -> init:'-> f:('-> 'a option -> 'b) -> 'b
              val remove : 'a t -> key -> unit
              val longest_match : 'a t -> key -> (int * 'a) option
              val length : 'a t -> int
              val pp : 'Regular.Std.printer -> 'a t Regular.Std.printer
            end
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> string
          val str : unit -> t -> string
          val pps : unit -> t -> string
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.insn
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> string) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Op.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> string) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info = string * [ `Ver of string ] * string option
          val version : string
          val size_in_bytes : ?ver:string -> ?fmt:string -> t -> int
          val of_bytes : ?ver:string -> ?fmt:string -> Regular.Std.bytes -> t
          val to_bytes : ?ver:string -> ?fmt:string -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:string ->
            ?fmt:string -> Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:string -> ?fmt:string -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:string -> ?fmt:string -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:string ->
            ?fmt:string -> Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read : ?ver:string -> ?fmt:string -> string -> t
              val load :
                ?ver:string ->
                ?fmt:string -> Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:string ->
                ?fmt:string ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:string ->
                ?fmt:string ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write : ?ver:string -> ?fmt:string -> string -> t -> unit
              val save :
                ?ver:string ->
                ?fmt:string -> Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:string ->
                ?fmt:string ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:string ->
                ?fmt:string ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show : ?ver:string -> ?fmt:string -> t -> unit
              val print :
                ?ver:string -> ?fmt:string -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:string ->
            ver:string -> string -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:string ->
            ver:string -> string -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader : ?ver:string -> string -> unit
          val with_reader : ?ver:string -> string -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer : ?ver:string -> string -> unit
          val with_writer : ?ver:string -> string -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer : ?ver:string -> string -> unit
          val with_printer : ?ver:string -> string -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:string -> string -> t Regular.Std.reader option
          val find_writer :
            ?ver:string -> string -> t Regular.Std.writer option
        end
      module Block :
        sig
          type t = Bap.Std.block
          val sexp_of_t : t -> Sexplib.Sexp.t
          val create :
            Bap.Std.mem ->
            (Bap.Std.mem * Bap.Std.insn) list -> Bap.Std.Block.t
          val addr : Bap.Std.Block.t -> Bap.Std.addr
          val memory : Bap.Std.Block.t -> Bap.Std.mem
          val leader : Bap.Std.Block.t -> Bap.Std.insn
          val terminator : Bap.Std.Block.t -> Bap.Std.insn
          val insns : Bap.Std.Block.t -> (Bap.Std.mem * Bap.Std.insn) list
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.block
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
            end
          val hash : t -> Core_kernel__.Import.int
          val compare : t -> t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Insn.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
        end
      module Graphs :
        sig
          module Cfg :
            sig
              type t = cfg
              type node = block
              type edge
              module Node :
                sig
                  type t = node
                  type graph = cfg
                  type label
                  type edge = edge
                  val create : label -> t
                  val label : t -> label
                  val mem : t -> graph -> bool
                  val succs : t -> graph -> t Regular.Std.seq
                  val preds : t -> graph -> t Regular.Std.seq
                  val inputs : t -> graph -> edge Regular.Std.seq
                  val outputs : t -> graph -> edge Regular.Std.seq
                  val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
                  val insert : t -> graph -> graph
                  val update : t -> label -> graph -> graph
                  val remove : t -> graph -> graph
                  val has_edge : t -> t -> graph -> bool
                  val edge : t -> t -> graph -> edge option
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val comparator :
                    (t, comparator_witness) Base__.Comparator.comparator
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = node
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (node, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : node -> '-> 'a t
                          val of_alist :
                            (node * 'a) list ->
                            [ `Duplicate_key of node | `Ok of 'a t ]
                          val of_alist_or_error :
                            (node * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (node * 'a) list -> 'a t
                          val of_alist_multi : (node * 'a) list -> 'a list t
                          val of_alist_fold :
                            (node * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (node * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (node * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> node * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of node | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            node Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:node -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:node -> data:'-> 'a list t
                          val remove_multi : 'a list t -> node -> 'a list t
                          val change :
                            'a t ->
                            node -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> node -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> node -> 'a option
                          val find_exn : 'a t -> node -> 'a
                          val remove : 'a t -> node -> 'a t
                          val mem : 'a t -> node -> bool
                          val iter_keys : 'a t -> f:(node -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:node -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:node ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:node -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:node -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:node ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:node -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:node -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:node ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:node -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> node list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (node * 'a) list
                          val validate :
                            name:(node -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:node ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (node, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (node * 'a) option
                          val min_elt_exn : 'a t -> node * 'a
                          val max_elt : 'a t -> (node * 'a) option
                          val max_elt_exn : 'a t -> node * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:node -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:node -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:node -> data:'-> bool) -> int
                          val split :
                            'a t -> node -> 'a t * (node * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:node Base__.Maybe_bound.t ->
                            upper_bound:node Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:node ->
                            max:node ->
                            init:'->
                            f:(key:node -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:node -> max:node -> (node * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> node -> (node * 'a) option
                          val nth : 'a t -> int -> (node * 'a) option
                          val nth_exn : 'a t -> int -> node * 'a
                          val rank : 'a t -> node -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:node ->
                            ?keys_less_or_equal_to:node ->
                            'a t -> (node * 'a) Base__.Sequence.t
                          val obs :
                            node Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            node Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (node, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : node -> '-> 'a t
                      val of_alist :
                        (node * 'a) list ->
                        [ `Duplicate_key of node | `Ok of 'a t ]
                      val of_alist_or_error :
                        (node * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (node * 'a) list -> 'a t
                      val of_alist_multi : (node * 'a) list -> 'a list t
                      val of_alist_fold :
                        (node * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (node * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (node * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of node | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:node -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:node -> data:'-> 'a list t
                      val remove_multi : 'a list t -> node -> 'a list t
                      val change :
                        'a t -> node -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> node -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> node -> 'a option
                      val find_exn : 'a t -> node -> 'a
                      val remove : 'a t -> node -> 'a t
                      val mem : 'a t -> node -> bool
                      val iter_keys : 'a t -> f:(node -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:node -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:node -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:node -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:node -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> node list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (node * 'a) list
                      val validate :
                        name:(node -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (node, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (node * 'a) option
                      val min_elt_exn : 'a t -> node * 'a
                      val max_elt : 'a t -> (node * 'a) option
                      val max_elt_exn : 'a t -> node * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:node -> data:'-> bool) -> int
                      val split :
                        'a t -> node -> 'a t * (node * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:node Base__.Maybe_bound.t ->
                        upper_bound:node Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:node ->
                        max:node ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:node -> max:node -> (node * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> node -> (node * 'a) option
                      val nth : 'a t -> int -> (node * 'a) option
                      val nth_exn : 'a t -> int -> node * 'a
                      val rank : 'a t -> node -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:node ->
                        ?keys_less_or_equal_to:node ->
                        'a t -> (node * 'a) Base__.Sequence.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> node
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : node Bin_prot.Type_class.t
                                   val bin_read_t : node Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> node)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     node Bin_prot.Type_class.reader
                                   val bin_size_t : node Bin_prot.Size.sizer
                                   val bin_write_t :
                                     node Bin_prot.Write.writer
                                   val bin_writer_t :
                                     node Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     node -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = node
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (node, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(node -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> node -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(node -> bool) -> bool
                          val for_all : t -> f:(node -> bool) -> bool
                          val count : t -> f:(node -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(node -> 'sum) -> 'sum
                          val find : t -> f:(node -> bool) -> node option
                          val find_map :
                            t -> f:(node -> 'a option) -> 'a option
                          val to_list : t -> node list
                          val to_array : t -> node array
                          val invariants : t -> bool
                          val mem : t -> node -> bool
                          val add : t -> node -> t
                          val remove : t -> node -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t ->
                            (node, node) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               node ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(node -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of node * node
                               | `Left of node
                               | `Right of node ] -> unit) ->
                            unit
                          val filter : t -> f:(node -> bool) -> t
                          val partition_tf : t -> f:(node -> bool) -> t * t
                          val elements : t -> node list
                          val min_elt : t -> node option
                          val min_elt_exn : t -> node
                          val max_elt : t -> node option
                          val max_elt_exn : t -> node
                          val choose : t -> node option
                          val choose_exn : t -> node
                          val split : t -> node -> t * node option * t
                          val group_by :
                            t -> equiv:(node -> node -> bool) -> t list
                          val find_exn : t -> f:(node -> bool) -> node
                          val find_index : t -> int -> node option
                          val nth : t -> int -> node option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:node ->
                            ?less_or_equal_to:node ->
                            t -> node Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:node ->
                            ?less_or_equal_to:node ->
                            t ->
                            t ->
                            (node, node)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(node -> 'data) ->
                            (node, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            node Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            node Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : node -> t
                          val union_list : t list -> t
                          val of_list : node list -> t
                          val of_array : node array -> t
                          val of_sorted_array :
                            node array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : node array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> node) -> t
                          val stable_dedup_list : node list -> node list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> node) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> node option) -> t
                          val of_tree : t -> t
                          val of_hash_set :
                            node Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (node, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            node Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> node
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (node, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(node -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(node -> bool) -> bool
                      val for_all : t -> f:(node -> bool) -> bool
                      val count : t -> f:(node -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(node -> 'sum) -> 'sum
                      val find : t -> f:(node -> bool) -> node option
                      val find_map : t -> f:(node -> 'a option) -> 'a option
                      val to_list : t -> node list
                      val to_array : t -> node array
                      val invariants : t -> bool
                      val mem : t -> node -> bool
                      val add : t -> node -> t
                      val remove : t -> node -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (node, node) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           node ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(node -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of node * node
                           | `Left of node
                           | `Right of node ] -> unit) ->
                        unit
                      val filter : t -> f:(node -> bool) -> t
                      val partition_tf : t -> f:(node -> bool) -> t * t
                      val elements : t -> node list
                      val min_elt : t -> node option
                      val min_elt_exn : t -> node
                      val max_elt : t -> node option
                      val max_elt_exn : t -> node
                      val choose : t -> node option
                      val choose_exn : t -> node
                      val split : t -> node -> t * node option * t
                      val group_by :
                        t -> equiv:(node -> node -> bool) -> t list
                      val find_exn : t -> f:(node -> bool) -> node
                      val find_index : t -> int -> node option
                      val nth : t -> int -> node option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node ->
                        t ->
                        t ->
                        (node, node)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(node -> 'data) ->
                        (node, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : node -> t
                      val union_list : t list -> t
                      val of_list : node list -> t
                      val of_array : node array -> t
                      val of_sorted_array : node array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : node array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node) -> t
                      val stable_dedup_list : node list -> node list
                      val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : node Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (node, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> node
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : node Bin_prot.Type_class.t
                                   val bin_read_t : node Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> node)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     node Bin_prot.Type_class.reader
                                   val bin_size_t : node Bin_prot.Size.sizer
                                   val bin_write_t :
                                     node Bin_prot.Write.writer
                                   val bin_writer_t :
                                     node Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     node -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val compare : t -> t -> Core_kernel__.Import.int
                  val hashable :
                    t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl = ('a, 'b) Block.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = node
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> node -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> node -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> node -> 'a
                      val enqueue :
                        'a t -> node -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> node -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> node -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (node * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> node Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (node * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> node * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> node -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> node -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> node -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:node -> data:'-> 'b) -> 'b
                    end
                end
              module Edge :
                sig
                  type t = edge
                  type node = block
                  type graph = cfg
                  type label = edge
                  val create : node -> node -> label -> t
                  val label : t -> label
                  val src : t -> node
                  val dst : t -> node
                  val mem : t -> graph -> bool
                  val insert : t -> graph -> graph
                  val update : t -> label -> graph -> graph
                  val remove : t -> graph -> graph
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val comparator :
                    (t, comparator_witness) Base__.Comparator.comparator
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = edge
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : edge -> '-> 'a t
                          val of_alist :
                            (edge * 'a) list ->
                            [ `Duplicate_key of edge | `Ok of 'a t ]
                          val of_alist_or_error :
                            (edge * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (edge * 'a) list -> 'a t
                          val of_alist_multi : (edge * 'a) list -> 'a list t
                          val of_alist_fold :
                            (edge * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (edge * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (edge * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> edge * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of edge | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            edge Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:edge -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:edge -> data:'-> 'a list t
                          val remove_multi : 'a list t -> edge -> 'a list t
                          val change :
                            'a t ->
                            edge -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> edge -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> edge -> 'a option
                          val find_exn : 'a t -> edge -> 'a
                          val remove : 'a t -> edge -> 'a t
                          val mem : 'a t -> edge -> bool
                          val iter_keys : 'a t -> f:(edge -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:edge -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:edge ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:edge ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:edge -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:edge ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> edge list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (edge * 'a) list
                          val validate :
                            name:(edge -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:edge ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (edge, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (edge * 'a) option
                          val min_elt_exn : 'a t -> edge * 'a
                          val max_elt : 'a t -> (edge * 'a) option
                          val max_elt_exn : 'a t -> edge * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:edge -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:edge -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:edge -> data:'-> bool) -> int
                          val split :
                            'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:edge Base__.Maybe_bound.t ->
                            upper_bound:edge Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:edge ->
                            max:edge ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:edge -> max:edge -> (edge * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> edge -> (edge * 'a) option
                          val nth : 'a t -> int -> (edge * 'a) option
                          val nth_exn : 'a t -> int -> edge * 'a
                          val rank : 'a t -> edge -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:edge ->
                            ?keys_less_or_equal_to:edge ->
                            'a t -> (edge * 'a) Base__.Sequence.t
                          val obs :
                            edge Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            edge Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : edge Bin_prot.Type_class.t
                                   val bin_read_t : edge Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> edge)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     edge Bin_prot.Type_class.reader
                                   val bin_size_t : edge Bin_prot.Size.sizer
                                   val bin_write_t :
                                     edge Bin_prot.Write.writer
                                   val bin_writer_t :
                                     edge Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     edge -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = edge
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (edge, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(edge -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> edge -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(edge -> bool) -> bool
                          val for_all : t -> f:(edge -> bool) -> bool
                          val count : t -> f:(edge -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(edge -> 'sum) -> 'sum
                          val find : t -> f:(edge -> bool) -> edge option
                          val find_map :
                            t -> f:(edge -> 'a option) -> 'a option
                          val to_list : t -> edge list
                          val to_array : t -> edge array
                          val invariants : t -> bool
                          val mem : t -> edge -> bool
                          val add : t -> edge -> t
                          val remove : t -> edge -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t ->
                            (edge, edge) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               edge ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(edge -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of edge * edge
                               | `Left of edge
                               | `Right of edge ] -> unit) ->
                            unit
                          val filter : t -> f:(edge -> bool) -> t
                          val partition_tf : t -> f:(edge -> bool) -> t * t
                          val elements : t -> edge list
                          val min_elt : t -> edge option
                          val min_elt_exn : t -> edge
                          val max_elt : t -> edge option
                          val max_elt_exn : t -> edge
                          val choose : t -> edge option
                          val choose_exn : t -> edge
                          val split : t -> edge -> t * edge option * t
                          val group_by :
                            t -> equiv:(edge -> edge -> bool) -> t list
                          val find_exn : t -> f:(edge -> bool) -> edge
                          val find_index : t -> int -> edge option
                          val nth : t -> int -> edge option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:edge ->
                            ?less_or_equal_to:edge ->
                            t -> edge Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:edge ->
                            ?less_or_equal_to:edge ->
                            t ->
                            t ->
                            (edge, edge)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(edge -> 'data) ->
                            (edge, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            edge Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            edge Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : edge -> t
                          val union_list : t list -> t
                          val of_list : edge list -> t
                          val of_array : edge array -> t
                          val of_sorted_array :
                            edge array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : edge array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> edge) -> t
                          val stable_dedup_list : edge list -> edge list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> edge) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> edge option) -> t
                          val of_tree : t -> t
                          val of_hash_set :
                            edge Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            edge Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (edge, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : edge Bin_prot.Type_class.t
                                   val bin_read_t : edge Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> edge)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     edge Bin_prot.Type_class.reader
                                   val bin_size_t : edge Bin_prot.Size.sizer
                                   val bin_write_t :
                                     edge Bin_prot.Write.writer
                                   val bin_writer_t :
                                     edge Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     edge -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val compare : t -> t -> Core_kernel__.Import.int
                  val hashable :
                    t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = edge
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> edge -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> edge -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> edge -> 'a
                      val enqueue :
                        'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> edge -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> edge -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (edge * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> edge Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (edge * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> edge * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> edge -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> edge -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> edge -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                    end
                end
              val empty : t
              val nodes : t -> node Regular.Std.seq
              val edges : t -> edge Regular.Std.seq
              val is_directed : bool
              val number_of_edges : t -> int
              val number_of_nodes : t -> int
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = cfg
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (cfg, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : cfg -> '-> 'a t
                      val of_alist :
                        (cfg * 'a) list ->
                        [ `Duplicate_key of cfg | `Ok of 'a t ]
                      val of_alist_or_error :
                        (cfg * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (cfg * 'a) list -> 'a t
                      val of_alist_multi : (cfg * 'a) list -> 'a list t
                      val of_alist_fold :
                        (cfg * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (cfg * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (cfg * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (cfg * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> cfg * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:cfg -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of cfg | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (cfg, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        cfg Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:cfg -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:cfg -> data:'-> 'a list t
                      val remove_multi : 'a list t -> cfg -> 'a list t
                      val change :
                        'a t -> cfg -> f:('a option -> 'a option) -> 'a t
                      val update : 'a t -> cfg -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> cfg -> 'a option
                      val find_exn : 'a t -> cfg -> 'a
                      val remove : 'a t -> cfg -> 'a t
                      val mem : 'a t -> cfg -> bool
                      val iter_keys : 'a t -> f:(cfg -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:cfg -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:cfg ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi : 'a t -> f:(key:cfg -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:cfg ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(cfg -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:cfg -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:cfg -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:cfg -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t -> f:(key:cfg -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> cfg list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (cfg * 'a) list
                      val validate :
                        name:(cfg -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:cfg ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (cfg, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (cfg * 'a) option
                      val min_elt_exn : 'a t -> cfg * 'a
                      val max_elt : 'a t -> (cfg * 'a) option
                      val max_elt_exn : 'a t -> cfg * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:cfg -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:cfg -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:cfg -> data:'-> bool) -> int
                      val split :
                        'a t -> cfg -> 'a t * (cfg * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:cfg Base__.Maybe_bound.t ->
                        upper_bound:cfg Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:cfg ->
                        max:cfg ->
                        init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:cfg -> max:cfg -> (cfg * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> cfg -> (cfg * 'a) option
                      val nth : 'a t -> int -> (cfg * 'a) option
                      val nth_exn : 'a t -> int -> cfg * 'a
                      val rank : 'a t -> cfg -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:cfg ->
                        ?keys_less_or_equal_to:cfg ->
                        'a t -> (cfg * 'a) Base__.Sequence.t
                      val obs :
                        cfg Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        cfg Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig val t_of_sexp : Sexplib.Sexp.t -> cfg end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (cfg, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : cfg -> '-> 'a t
                  val of_alist :
                    (cfg * 'a) list ->
                    [ `Duplicate_key of cfg | `Ok of 'a t ]
                  val of_alist_or_error :
                    (cfg * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (cfg * 'a) list -> 'a t
                  val of_alist_multi : (cfg * 'a) list -> 'a list t
                  val of_alist_fold :
                    (cfg * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (cfg * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (cfg * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (cfg * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> cfg * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:cfg -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of cfg | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (cfg, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    cfg Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:cfg -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:cfg -> data:'-> 'a list t
                  val remove_multi : 'a list t -> cfg -> 'a list t
                  val change :
                    'a t -> cfg -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> cfg -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> cfg -> 'a option
                  val find_exn : 'a t -> cfg -> 'a
                  val remove : 'a t -> cfg -> 'a t
                  val mem : 'a t -> cfg -> bool
                  val iter_keys : 'a t -> f:(cfg -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:cfg -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:cfg ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:cfg -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:cfg ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(cfg -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:cfg -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:cfg -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:cfg -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:cfg -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> cfg list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (cfg * 'a) list
                  val validate :
                    name:(cfg -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:cfg ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (cfg, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (cfg * 'a) option
                  val min_elt_exn : 'a t -> cfg * 'a
                  val max_elt : 'a t -> (cfg * 'a) option
                  val max_elt_exn : 'a t -> cfg * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:cfg -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:cfg -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:cfg -> data:'-> bool) -> int
                  val split : 'a t -> cfg -> 'a t * (cfg * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:cfg Base__.Maybe_bound.t ->
                    upper_bound:cfg Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:cfg ->
                    max:cfg ->
                    init:'-> f:(key:cfg -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:cfg -> max:cfg -> (cfg * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> cfg -> (cfg * 'a) option
                  val nth : 'a t -> int -> (cfg * 'a) option
                  val nth_exn : 'a t -> int -> cfg * 'a
                  val rank : 'a t -> cfg -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:cfg ->
                    ?keys_less_or_equal_to:cfg ->
                    'a t -> (cfg * 'a) Base__.Sequence.t
                  val obs :
                    cfg Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    cfg Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> cfg end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : cfg Bin_prot.Type_class.t
                               val bin_read_t : cfg Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> cfg)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 cfg Bin_prot.Type_class.reader
                               val bin_size_t : cfg Bin_prot.Size.sizer
                               val bin_write_t : cfg Bin_prot.Write.writer
                               val bin_writer_t :
                                 cfg Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 cfg -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = cfg
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (cfg, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(cfg -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> cfg -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> cfg -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(cfg -> bool) -> bool
                      val for_all : t -> f:(cfg -> bool) -> bool
                      val count : t -> f:(cfg -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(cfg -> 'sum) -> 'sum
                      val find : t -> f:(cfg -> bool) -> cfg option
                      val find_map : t -> f:(cfg -> 'a option) -> 'a option
                      val to_list : t -> cfg list
                      val to_array : t -> cfg array
                      val invariants : t -> bool
                      val mem : t -> cfg -> bool
                      val add : t -> cfg -> t
                      val remove : t -> cfg -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (cfg, cfg) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           cfg ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(cfg -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of cfg * cfg
                           | `Left of cfg
                           | `Right of cfg ] -> unit) ->
                        unit
                      val filter : t -> f:(cfg -> bool) -> t
                      val partition_tf : t -> f:(cfg -> bool) -> t * t
                      val elements : t -> cfg list
                      val min_elt : t -> cfg option
                      val min_elt_exn : t -> cfg
                      val max_elt : t -> cfg option
                      val max_elt_exn : t -> cfg
                      val choose : t -> cfg option
                      val choose_exn : t -> cfg
                      val split : t -> cfg -> t * cfg option * t
                      val group_by :
                        t -> equiv:(cfg -> cfg -> bool) -> t list
                      val find_exn : t -> f:(cfg -> bool) -> cfg
                      val find_index : t -> int -> cfg option
                      val nth : t -> int -> cfg option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:cfg ->
                        ?less_or_equal_to:cfg -> t -> cfg Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:cfg ->
                        ?less_or_equal_to:cfg ->
                        t ->
                        t ->
                        (cfg, cfg)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(cfg -> 'data) ->
                        (cfg, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        cfg Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        cfg Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : cfg -> t
                      val union_list : t list -> t
                      val of_list : cfg list -> t
                      val of_array : cfg array -> t
                      val of_sorted_array : cfg array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : cfg array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> cfg) -> t
                      val stable_dedup_list : cfg list -> cfg list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> cfg) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> cfg option) -> t
                      val of_tree : t -> t
                      val of_hash_set : cfg Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (cfg, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (cfg, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        cfg Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> cfg
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (cfg, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(cfg -> unit) -> unit
                  val fold :
                    t -> init:'accum -> f:('accum -> cfg -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> cfg -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(cfg -> bool) -> bool
                  val for_all : t -> f:(cfg -> bool) -> bool
                  val count : t -> f:(cfg -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(cfg -> 'sum) -> 'sum
                  val find : t -> f:(cfg -> bool) -> cfg option
                  val find_map : t -> f:(cfg -> 'a option) -> 'a option
                  val to_list : t -> cfg list
                  val to_array : t -> cfg array
                  val invariants : t -> bool
                  val mem : t -> cfg -> bool
                  val add : t -> cfg -> t
                  val remove : t -> cfg -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (cfg, cfg) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       cfg ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(cfg -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of cfg * cfg | `Left of cfg | `Right of cfg ] ->
                       unit) ->
                    unit
                  val filter : t -> f:(cfg -> bool) -> t
                  val partition_tf : t -> f:(cfg -> bool) -> t * t
                  val elements : t -> cfg list
                  val min_elt : t -> cfg option
                  val min_elt_exn : t -> cfg
                  val max_elt : t -> cfg option
                  val max_elt_exn : t -> cfg
                  val choose : t -> cfg option
                  val choose_exn : t -> cfg
                  val split : t -> cfg -> t * cfg option * t
                  val group_by : t -> equiv:(cfg -> cfg -> bool) -> t list
                  val find_exn : t -> f:(cfg -> bool) -> cfg
                  val find_index : t -> int -> cfg option
                  val nth : t -> int -> cfg option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:cfg ->
                    ?less_or_equal_to:cfg -> t -> cfg Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:cfg ->
                    ?less_or_equal_to:cfg ->
                    t ->
                    t ->
                    (cfg, cfg)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(cfg -> 'data) ->
                    (cfg, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    cfg Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    cfg Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : cfg -> t
                  val union_list : t list -> t
                  val of_list : cfg list -> t
                  val of_array : cfg array -> t
                  val of_sorted_array : cfg array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : cfg array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> cfg) -> t
                  val stable_dedup_list : cfg list -> cfg list
                  val map : ('a, 'b) Base.Set.t -> f:('-> cfg) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> cfg option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : cfg Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (cfg, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (cfg, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    cfg Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> cfg end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : cfg Bin_prot.Type_class.t
                               val bin_read_t : cfg Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> cfg)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 cfg Bin_prot.Type_class.reader
                               val bin_size_t : cfg Bin_prot.Size.sizer
                               val bin_write_t : cfg Bin_prot.Write.writer
                               val bin_writer_t :
                                 cfg Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 cfg -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              val hash : t -> Core_kernel__.Import.int
              val compare : t -> t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = cfg
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> cfg -> Core_kernel__.Import.bool
                  val lookup : 'a t -> cfg -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> cfg -> 'a
                  val enqueue :
                    'a t -> cfg -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> cfg -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> cfg -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> cfg -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (cfg * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> cfg Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (cfg * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> cfg * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> cfg -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> cfg -> Core_kernel__.Import.unit
                  val replace : 'a t -> cfg -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> cfg -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:cfg -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:cfg -> data:'-> 'b) -> 'b
                end
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
            end
          module Callgraph :
            sig
              type t
              type node = tid
              type edge
              module Node :
                sig
                  type t = node
                  type graph = t
                  type label = t
                  type edge = edge
                  val create : label -> label
                  val label : label -> label
                  val mem : label -> graph -> bool
                  val succs : label -> graph -> label Regular.Std.seq
                  val preds : label -> graph -> label Regular.Std.seq
                  val inputs : label -> graph -> edge Regular.Std.seq
                  val outputs : label -> graph -> edge Regular.Std.seq
                  val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
                  val insert : label -> graph -> graph
                  val update : label -> label -> graph -> graph
                  val remove : label -> graph -> graph
                  val has_edge : label -> label -> graph -> bool
                  val edge : label -> label -> graph -> edge option
                  val ( >= ) : label -> label -> bool
                  val ( <= ) : label -> label -> bool
                  val ( = ) : label -> label -> bool
                  val ( > ) : label -> label -> bool
                  val ( < ) : label -> label -> bool
                  val ( <> ) : label -> label -> bool
                  val equal : label -> label -> bool
                  val min : label -> label -> label
                  val max : label -> label -> label
                  val ascending : label -> label -> int
                  val descending : label -> label -> int
                  val between : label -> low:label -> high:label -> bool
                  val clamp_exn : label -> min:label -> max:label -> label
                  val clamp :
                    label ->
                    min:label -> max:label -> label Base__.Or_error.t
                  type comparator_witness
                  val comparator :
                    (label, comparator_witness) Base__.Comparator.comparator
                  val validate_lbound :
                    min:label Base__.Maybe_bound.t ->
                    label Base__.Validate.check
                  val validate_ubound :
                    max:label Base__.Maybe_bound.t ->
                    label Base__.Validate.check
                  val validate_bound :
                    min:label Base__.Maybe_bound.t ->
                    max:label Base__.Maybe_bound.t ->
                    label Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : label -> label -> bool
                      val ( <= ) : label -> label -> bool
                      val ( = ) : label -> label -> bool
                      val ( > ) : label -> label -> bool
                      val ( < ) : label -> label -> bool
                      val ( <> ) : label -> label -> bool
                      val equal : label -> label -> bool
                      val compare : label -> label -> int
                      val min : label -> label -> label
                      val max : label -> label -> label
                    end
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = label
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (label, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : label -> '-> 'a t
                          val of_alist :
                            (label * 'a) list ->
                            [ `Duplicate_key of label | `Ok of 'a t ]
                          val of_alist_or_error :
                            (label * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (label * 'a) list -> 'a t
                          val of_alist_multi : (label * 'a) list -> 'a list t
                          val of_alist_fold :
                            (label * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (label * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (label * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> label * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of label | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            label Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:label -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:label -> data:'-> 'a list t
                          val remove_multi : 'a list t -> label -> 'a list t
                          val change :
                            'a t ->
                            label -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> label -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> label -> 'a option
                          val find_exn : 'a t -> label -> 'a
                          val remove : 'a t -> label -> 'a t
                          val mem : 'a t -> label -> bool
                          val iter_keys : 'a t -> f:(label -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:label -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:label ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:label -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:label -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:label ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:label -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:label -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:label ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:label -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> label list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (label * 'a) list
                          val validate :
                            name:(label -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:label ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (label, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (label * 'a) option
                          val min_elt_exn : 'a t -> label * 'a
                          val max_elt : 'a t -> (label * 'a) option
                          val max_elt_exn : 'a t -> label * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:label -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:label -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:label -> data:'-> bool) -> int
                          val split :
                            'a t ->
                            label -> 'a t * (label * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:label Base__.Maybe_bound.t ->
                            upper_bound:label Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:label ->
                            max:label ->
                            init:'->
                            f:(key:label -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t ->
                            min:label -> max:label -> (label * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> label -> (label * 'a) option
                          val nth : 'a t -> int -> (label * 'a) option
                          val nth_exn : 'a t -> int -> label * 'a
                          val rank : 'a t -> label -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:label ->
                            ?keys_less_or_equal_to:label ->
                            'a t -> (label * 'a) Base__.Sequence.t
                          val obs :
                            label Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            label Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> label
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (label, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : label -> '-> 'a t
                      val of_alist :
                        (label * 'a) list ->
                        [ `Duplicate_key of label | `Ok of 'a t ]
                      val of_alist_or_error :
                        (label * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (label * 'a) list -> 'a t
                      val of_alist_multi : (label * 'a) list -> 'a list t
                      val of_alist_fold :
                        (label * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (label * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (label * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> label * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of label | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        label Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:label -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:label -> data:'-> 'a list t
                      val remove_multi : 'a list t -> label -> 'a list t
                      val change :
                        'a t -> label -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> label -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> label -> 'a option
                      val find_exn : 'a t -> label -> 'a
                      val remove : 'a t -> label -> 'a t
                      val mem : 'a t -> label -> bool
                      val iter_keys : 'a t -> f:(label -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:label -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:label ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:label ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:label -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:label -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:label ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:label -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> label list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (label * 'a) list
                      val validate :
                        name:(label -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:label ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (label, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (label * 'a) option
                      val min_elt_exn : 'a t -> label * 'a
                      val max_elt : 'a t -> (label * 'a) option
                      val max_elt_exn : 'a t -> label * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:label -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:label -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:label -> data:'-> bool) -> int
                      val split :
                        'a t -> label -> 'a t * (label * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:label Base__.Maybe_bound.t ->
                        upper_bound:label Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:label ->
                        max:label ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:label -> max:label -> (label * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> label -> (label * 'a) option
                      val nth : 'a t -> int -> (label * 'a) option
                      val nth_exn : 'a t -> int -> label * 'a
                      val rank : 'a t -> label -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:label ->
                        ?keys_less_or_equal_to:label ->
                        'a t -> (label * 'a) Base__.Sequence.t
                      val obs :
                        label Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        label Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> label
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : label Bin_prot.Type_class.t
                                   val bin_read_t :
                                     label Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> label)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     label Bin_prot.Type_class.reader
                                   val bin_size_t : label Bin_prot.Size.sizer
                                   val bin_write_t :
                                     label Bin_prot.Write.writer
                                   val bin_writer_t :
                                     label Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     label -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = label
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (label, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(label -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> label -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum ->
                               label -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(label -> bool) -> bool
                          val for_all : t -> f:(label -> bool) -> bool
                          val count : t -> f:(label -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(label -> 'sum) -> 'sum
                          val find : t -> f:(label -> bool) -> label option
                          val find_map :
                            t -> f:(label -> 'a option) -> 'a option
                          val to_list : t -> label list
                          val to_array : t -> label array
                          val invariants : t -> bool
                          val mem : t -> label -> bool
                          val add : t -> label -> t
                          val remove : t -> label -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t ->
                            (label, label) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               label ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(label -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of label * label
                               | `Left of label
                               | `Right of label ] -> unit) ->
                            unit
                          val filter : t -> f:(label -> bool) -> t
                          val partition_tf : t -> f:(label -> bool) -> t * t
                          val elements : t -> label list
                          val min_elt : t -> label option
                          val min_elt_exn : t -> label
                          val max_elt : t -> label option
                          val max_elt_exn : t -> label
                          val choose : t -> label option
                          val choose_exn : t -> label
                          val split : t -> label -> t * label option * t
                          val group_by :
                            t -> equiv:(label -> label -> bool) -> t list
                          val find_exn : t -> f:(label -> bool) -> label
                          val find_index : t -> int -> label option
                          val nth : t -> int -> label option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:label ->
                            ?less_or_equal_to:label ->
                            t -> label Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:label ->
                            ?less_or_equal_to:label ->
                            t ->
                            t ->
                            (label, label)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(label -> 'data) ->
                            (label, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            label Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            label Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : label -> t
                          val union_list : t list -> t
                          val of_list : label list -> t
                          val of_array : label array -> t
                          val of_sorted_array :
                            label array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : label array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> label) -> t
                          val stable_dedup_list : label list -> label list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> label) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> label option) -> t
                          val of_tree : t -> t
                          val of_hash_set :
                            label Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (label, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (label, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            label Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp :
                                         Sexplib.Sexp.t -> label
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (label, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(label -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> label -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(label -> bool) -> bool
                      val for_all : t -> f:(label -> bool) -> bool
                      val count : t -> f:(label -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(label -> 'sum) -> 'sum
                      val find : t -> f:(label -> bool) -> label option
                      val find_map : t -> f:(label -> 'a option) -> 'a option
                      val to_list : t -> label list
                      val to_array : t -> label array
                      val invariants : t -> bool
                      val mem : t -> label -> bool
                      val add : t -> label -> t
                      val remove : t -> label -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (label, label) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           label ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(label -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of label * label
                           | `Left of label
                           | `Right of label ] -> unit) ->
                        unit
                      val filter : t -> f:(label -> bool) -> t
                      val partition_tf : t -> f:(label -> bool) -> t * t
                      val elements : t -> label list
                      val min_elt : t -> label option
                      val min_elt_exn : t -> label
                      val max_elt : t -> label option
                      val max_elt_exn : t -> label
                      val choose : t -> label option
                      val choose_exn : t -> label
                      val split : t -> label -> t * label option * t
                      val group_by :
                        t -> equiv:(label -> label -> bool) -> t list
                      val find_exn : t -> f:(label -> bool) -> label
                      val find_index : t -> int -> label option
                      val nth : t -> int -> label option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:label ->
                        ?less_or_equal_to:label ->
                        t -> label Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:label ->
                        ?less_or_equal_to:label ->
                        t ->
                        t ->
                        (label, label)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(label -> 'data) ->
                        (label, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        label Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        label Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : label -> t
                      val union_list : t list -> t
                      val of_list : label list -> t
                      val of_array : label array -> t
                      val of_sorted_array :
                        label array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : label array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> label) -> t
                      val stable_dedup_list : label list -> label list
                      val map : ('a, 'b) Base.Set.t -> f:('-> label) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> label option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : label Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (label, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (label, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        label Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> label
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : label Bin_prot.Type_class.t
                                   val bin_read_t :
                                     label Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> label)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     label Bin_prot.Type_class.reader
                                   val bin_size_t : label Bin_prot.Size.sizer
                                   val bin_write_t :
                                     label Bin_prot.Write.writer
                                   val bin_writer_t :
                                     label Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     label -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  val hash : label -> Core_kernel__.Import.int
                  val compare : label -> label -> Core_kernel__.Import.int
                  val hashable :
                    label Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = label
                      type ('a, 'b) hashtbl = ('a, 'b) Cfg.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                    end
                  module Hash_set :
                    sig
                      type elt = label
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = label
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> label -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> label -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> label -> 'a
                      val enqueue :
                        'a t -> label -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> label -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> label -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> label -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (label * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> label Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (label * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> label * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> label -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> label -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> label -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> label -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:label -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:label -> data:'-> 'b) -> 'b
                    end
                end
              module Edge :
                sig
                  type t = edge
                  type node = tid
                  type graph = Node.graph
                  type label = jmp term list
                  val create : node -> node -> label -> t
                  val label : t -> label
                  val src : t -> node
                  val dst : t -> node
                  val mem : t -> graph -> bool
                  val insert : t -> graph -> graph
                  val update : t -> label -> graph -> graph
                  val remove : t -> graph -> graph
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val comparator :
                    (t, comparator_witness) Base__.Comparator.comparator
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = edge
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : edge -> '-> 'a t
                          val of_alist :
                            (edge * 'a) list ->
                            [ `Duplicate_key of edge | `Ok of 'a t ]
                          val of_alist_or_error :
                            (edge * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (edge * 'a) list -> 'a t
                          val of_alist_multi : (edge * 'a) list -> 'a list t
                          val of_alist_fold :
                            (edge * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (edge * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (edge * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> edge * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of edge | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            edge Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:edge -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:edge -> data:'-> 'a list t
                          val remove_multi : 'a list t -> edge -> 'a list t
                          val change :
                            'a t ->
                            edge -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> edge -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> edge -> 'a option
                          val find_exn : 'a t -> edge -> 'a
                          val remove : 'a t -> edge -> 'a t
                          val mem : 'a t -> edge -> bool
                          val iter_keys : 'a t -> f:(edge -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:edge -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:edge ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:edge ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:edge -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:edge ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> edge list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (edge * 'a) list
                          val validate :
                            name:(edge -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:edge ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (edge, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (edge * 'a) option
                          val min_elt_exn : 'a t -> edge * 'a
                          val max_elt : 'a t -> (edge * 'a) option
                          val max_elt_exn : 'a t -> edge * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:edge -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:edge -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:edge -> data:'-> bool) -> int
                          val split :
                            'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:edge Base__.Maybe_bound.t ->
                            upper_bound:edge Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:edge ->
                            max:edge ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:edge -> max:edge -> (edge * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> edge -> (edge * 'a) option
                          val nth : 'a t -> int -> (edge * 'a) option
                          val nth_exn : 'a t -> int -> edge * 'a
                          val rank : 'a t -> edge -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:edge ->
                            ?keys_less_or_equal_to:edge ->
                            'a t -> (edge * 'a) Base__.Sequence.t
                          val obs :
                            edge Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            edge Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : edge Bin_prot.Type_class.t
                                   val bin_read_t : edge Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> edge)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     edge Bin_prot.Type_class.reader
                                   val bin_size_t : edge Bin_prot.Size.sizer
                                   val bin_write_t :
                                     edge Bin_prot.Write.writer
                                   val bin_writer_t :
                                     edge Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     edge -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = edge
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (edge, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(edge -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> edge -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(edge -> bool) -> bool
                          val for_all : t -> f:(edge -> bool) -> bool
                          val count : t -> f:(edge -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(edge -> 'sum) -> 'sum
                          val find : t -> f:(edge -> bool) -> edge option
                          val find_map :
                            t -> f:(edge -> 'a option) -> 'a option
                          val to_list : t -> edge list
                          val to_array : t -> edge array
                          val invariants : t -> bool
                          val mem : t -> edge -> bool
                          val add : t -> edge -> t
                          val remove : t -> edge -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t ->
                            (edge, edge) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               edge ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(edge -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of edge * edge
                               | `Left of edge
                               | `Right of edge ] -> unit) ->
                            unit
                          val filter : t -> f:(edge -> bool) -> t
                          val partition_tf : t -> f:(edge -> bool) -> t * t
                          val elements : t -> edge list
                          val min_elt : t -> edge option
                          val min_elt_exn : t -> edge
                          val max_elt : t -> edge option
                          val max_elt_exn : t -> edge
                          val choose : t -> edge option
                          val choose_exn : t -> edge
                          val split : t -> edge -> t * edge option * t
                          val group_by :
                            t -> equiv:(edge -> edge -> bool) -> t list
                          val find_exn : t -> f:(edge -> bool) -> edge
                          val find_index : t -> int -> edge option
                          val nth : t -> int -> edge option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:edge ->
                            ?less_or_equal_to:edge ->
                            t -> edge Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:edge ->
                            ?less_or_equal_to:edge ->
                            t ->
                            t ->
                            (edge, edge)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(edge -> 'data) ->
                            (edge, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            edge Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            edge Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : edge -> t
                          val union_list : t list -> t
                          val of_list : edge list -> t
                          val of_array : edge array -> t
                          val of_sorted_array :
                            edge array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : edge array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> edge) -> t
                          val stable_dedup_list : edge list -> edge list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> edge) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> edge option) -> t
                          val of_tree : t -> t
                          val of_hash_set :
                            edge Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            edge Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (edge, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : edge Bin_prot.Type_class.t
                                   val bin_read_t : edge Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> edge)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     edge Bin_prot.Type_class.reader
                                   val bin_size_t : edge Bin_prot.Size.sizer
                                   val bin_write_t :
                                     edge Bin_prot.Write.writer
                                   val bin_writer_t :
                                     edge Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     edge -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val compare : t -> t -> Core_kernel__.Import.int
                  val hashable :
                    t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = edge
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> edge -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> edge -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> edge -> 'a
                      val enqueue :
                        'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> edge -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> edge -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (edge * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> edge Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (edge * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> edge * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> edge -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> edge -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> edge -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                    end
                end
              val empty : t
              val nodes : t -> node Regular.Std.seq
              val edges : t -> edge Regular.Std.seq
              val is_directed : bool
              val number_of_edges : t -> int
              val number_of_nodes : t -> int
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = Edge.graph
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (Key.t, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : Key.t -> '-> 'a t
                      val of_alist :
                        (Key.t * 'a) list ->
                        [ `Duplicate_key of Key.t | `Ok of 'a t ]
                      val of_alist_or_error :
                        (Key.t * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (Key.t * 'a) list -> 'a t
                      val of_alist_multi : (Key.t * 'a) list -> 'a list t
                      val of_alist_fold :
                        (Key.t * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (Key.t * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (Key.t * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Key.t * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of Key.t | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        Key.t Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:Key.t -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:Key.t -> data:'-> 'a list t
                      val remove_multi : 'a list t -> Key.t -> 'a list t
                      val change :
                        'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> Key.t -> 'a option
                      val find_exn : 'a t -> Key.t -> 'a
                      val remove : 'a t -> Key.t -> 'a t
                      val mem : 'a t -> Key.t -> bool
                      val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:Key.t ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> Key.t list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (Key.t * 'a) list
                      val validate :
                        name:(Key.t -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (Key.t, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (Key.t * 'a) option
                      val min_elt_exn : 'a t -> Key.t * 'a
                      val max_elt : 'a t -> (Key.t * 'a) option
                      val max_elt_exn : 'a t -> Key.t * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> int
                      val split :
                        'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:Key.t Base__.Maybe_bound.t ->
                        upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:Key.t ->
                        max:Key.t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> Key.t -> (Key.t * 'a) option
                      val nth : 'a t -> int -> (Key.t * 'a) option
                      val nth_exn : 'a t -> int -> Key.t * 'a
                      val rank : 'a t -> Key.t -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:Key.t ->
                        ?keys_less_or_equal_to:Key.t ->
                        'a t -> (Key.t * 'a) Base__.Sequence.t
                      val obs :
                        Key.t Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : Key.t Bin_prot.Type_class.t
                               val bin_read_t : Key.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Key.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Key.t Bin_prot.Type_class.reader
                               val bin_size_t : Key.t Bin_prot.Size.sizer
                               val bin_write_t : Key.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Key.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Key.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = Edge.graph
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (Elt.t, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(Elt.t -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(Elt.t -> bool) -> bool
                      val for_all : t -> f:(Elt.t -> bool) -> bool
                      val count : t -> f:(Elt.t -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(Elt.t -> 'sum) -> 'sum
                      val find : t -> f:(Elt.t -> bool) -> Elt.t option
                      val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                      val to_list : t -> Elt.t list
                      val to_array : t -> Elt.t array
                      val invariants : t -> bool
                      val mem : t -> Elt.t -> bool
                      val add : t -> Elt.t -> t
                      val remove : t -> Elt.t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           Elt.t ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of Elt.t * Elt.t
                           | `Left of Elt.t
                           | `Right of Elt.t ] -> unit) ->
                        unit
                      val filter : t -> f:(Elt.t -> bool) -> t
                      val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                      val elements : t -> Elt.t list
                      val min_elt : t -> Elt.t option
                      val min_elt_exn : t -> Elt.t
                      val max_elt : t -> Elt.t option
                      val max_elt_exn : t -> Elt.t
                      val choose : t -> Elt.t option
                      val choose_exn : t -> Elt.t
                      val split : t -> Elt.t -> t * Elt.t option * t
                      val group_by :
                        t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                      val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                      val find_index : t -> int -> Elt.t option
                      val nth : t -> int -> Elt.t option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t -> Elt.t Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t ->
                        t ->
                        (Elt.t, Elt.t)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(Elt.t -> 'data) ->
                        (Elt.t, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        Elt.t Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : Elt.t -> t
                      val union_list : t list -> t
                      val of_list : Elt.t list -> t
                      val of_array : Elt.t array -> t
                      val of_sorted_array :
                        Elt.t array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : Elt.t array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Elt.t) -> t
                      val stable_dedup_list : Elt.t list -> Elt.t list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t option) -> t
                      val of_tree : t -> t
                      val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (Elt.t, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        Elt.t Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (Elt.t, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : Elt.t Bin_prot.Type_class.t
                               val bin_read_t : Elt.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Elt.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Elt.t Bin_prot.Type_class.reader
                               val bin_size_t : Elt.t Bin_prot.Size.sizer
                               val bin_write_t : Elt.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Elt.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Elt.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              val hash : t -> Core_kernel__.Import.int
              val compare : t -> t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = Hash_set.elt
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> Key.t -> 'a
                  val enqueue :
                    'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> Key.t Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> Key.t * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
                  val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                end
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
            end
          module Ir :
            sig
              type t
              type edge
              type node
              module Edge :
                sig
                  type t = edge
                  type node = node
                  type graph = t
                  type label
                  val create : node -> node -> label -> t
                  val label : t -> label
                  val src : t -> node
                  val dst : t -> node
                  val mem : t -> graph -> bool
                  val insert : t -> graph -> graph
                  val update : t -> label -> graph -> graph
                  val remove : t -> graph -> graph
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val comparator :
                    (t, comparator_witness) Base__.Comparator.comparator
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = edge
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : edge -> '-> 'a t
                          val of_alist :
                            (edge * 'a) list ->
                            [ `Duplicate_key of edge | `Ok of 'a t ]
                          val of_alist_or_error :
                            (edge * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (edge * 'a) list -> 'a t
                          val of_alist_multi : (edge * 'a) list -> 'a list t
                          val of_alist_fold :
                            (edge * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (edge * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (edge * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> edge * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of edge | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            edge Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:edge -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:edge -> data:'-> 'a list t
                          val remove_multi : 'a list t -> edge -> 'a list t
                          val change :
                            'a t ->
                            edge -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> edge -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> edge -> 'a option
                          val find_exn : 'a t -> edge -> 'a
                          val remove : 'a t -> edge -> 'a t
                          val mem : 'a t -> edge -> bool
                          val iter_keys : 'a t -> f:(edge -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:edge -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:edge ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:edge ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:edge -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:edge ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> edge list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (edge * 'a) list
                          val validate :
                            name:(edge -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:edge ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (edge, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (edge * 'a) option
                          val min_elt_exn : 'a t -> edge * 'a
                          val max_elt : 'a t -> (edge * 'a) option
                          val max_elt_exn : 'a t -> edge * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:edge -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:edge -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:edge -> data:'-> bool) -> int
                          val split :
                            'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:edge Base__.Maybe_bound.t ->
                            upper_bound:edge Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:edge ->
                            max:edge ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:edge -> max:edge -> (edge * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> edge -> (edge * 'a) option
                          val nth : 'a t -> int -> (edge * 'a) option
                          val nth_exn : 'a t -> int -> edge * 'a
                          val rank : 'a t -> edge -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:edge ->
                            ?keys_less_or_equal_to:edge ->
                            'a t -> (edge * 'a) Base__.Sequence.t
                          val obs :
                            edge Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            edge Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : edge Bin_prot.Type_class.t
                                   val bin_read_t : edge Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> edge)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     edge Bin_prot.Type_class.reader
                                   val bin_size_t : edge Bin_prot.Size.sizer
                                   val bin_write_t :
                                     edge Bin_prot.Write.writer
                                   val bin_writer_t :
                                     edge Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     edge -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = edge
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (edge, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(edge -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> edge -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(edge -> bool) -> bool
                          val for_all : t -> f:(edge -> bool) -> bool
                          val count : t -> f:(edge -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(edge -> 'sum) -> 'sum
                          val find : t -> f:(edge -> bool) -> edge option
                          val find_map :
                            t -> f:(edge -> 'a option) -> 'a option
                          val to_list : t -> edge list
                          val to_array : t -> edge array
                          val invariants : t -> bool
                          val mem : t -> edge -> bool
                          val add : t -> edge -> t
                          val remove : t -> edge -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t ->
                            (edge, edge) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               edge ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(edge -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of edge * edge
                               | `Left of edge
                               | `Right of edge ] -> unit) ->
                            unit
                          val filter : t -> f:(edge -> bool) -> t
                          val partition_tf : t -> f:(edge -> bool) -> t * t
                          val elements : t -> edge list
                          val min_elt : t -> edge option
                          val min_elt_exn : t -> edge
                          val max_elt : t -> edge option
                          val max_elt_exn : t -> edge
                          val choose : t -> edge option
                          val choose_exn : t -> edge
                          val split : t -> edge -> t * edge option * t
                          val group_by :
                            t -> equiv:(edge -> edge -> bool) -> t list
                          val find_exn : t -> f:(edge -> bool) -> edge
                          val find_index : t -> int -> edge option
                          val nth : t -> int -> edge option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:edge ->
                            ?less_or_equal_to:edge ->
                            t -> edge Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:edge ->
                            ?less_or_equal_to:edge ->
                            t ->
                            t ->
                            (edge, edge)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(edge -> 'data) ->
                            (edge, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            edge Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            edge Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : edge -> t
                          val union_list : t list -> t
                          val of_list : edge list -> t
                          val of_array : edge array -> t
                          val of_sorted_array :
                            edge array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : edge array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> edge) -> t
                          val stable_dedup_list : edge list -> edge list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> edge) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> edge option) -> t
                          val of_tree : t -> t
                          val of_hash_set :
                            edge Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            edge Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (edge, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : edge Bin_prot.Type_class.t
                                   val bin_read_t : edge Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> edge)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     edge Bin_prot.Type_class.reader
                                   val bin_size_t : edge Bin_prot.Size.sizer
                                   val bin_write_t :
                                     edge Bin_prot.Write.writer
                                   val bin_writer_t :
                                     edge Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     edge -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val compare : t -> t -> Core_kernel__.Import.int
                  val hashable :
                    t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl =
                          ('a, 'b) Callgraph.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = edge
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> edge -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> edge -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> edge -> 'a
                      val enqueue :
                        'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> edge -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> edge -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (edge * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> edge Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (edge * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> edge * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> edge -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> edge -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> edge -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                    end
                  val jmps :
                    [ `after | `before ] ->
                    Bap.Std.Graphs.Ir.t ->
                    graph -> Bap.Std.jmp Bap.Std.term Bap.Std.seq
                  val edges :
                    [ `after | `before ] ->
                    Bap.Std.Graphs.Ir.t ->
                    graph -> Bap.Std.Graphs.Ir.t Bap.Std.seq
                  val jmp : Bap.Std.Graphs.Ir.t -> Bap.Std.jmp Bap.Std.term
                  val tid : Bap.Std.Graphs.Ir.t -> Bap.Std.tid
                  val cond : Bap.Std.Graphs.Ir.t -> graph -> Bap.Std.exp
                  val to_string : t -> Trie.String.Suffix.key
                  val str : unit -> t -> Trie.String.Suffix.key
                  val pps : unit -> t -> Trie.String.Suffix.key
                  val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                  val pp_seq : Format.formatter -> t Seq.t -> unit
                  val pp : Base__.Import.Caml.Format.formatter -> t -> unit
                end
              module Node :
                sig
                  type t = node
                  type graph = Edge.graph
                  type label = blk term
                  type edge = Edge.t
                  val create : label -> t
                  val label : t -> label
                  val mem : t -> graph -> bool
                  val succs : t -> graph -> t Regular.Std.seq
                  val preds : t -> graph -> t Regular.Std.seq
                  val inputs : t -> graph -> edge Regular.Std.seq
                  val outputs : t -> graph -> edge Regular.Std.seq
                  val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
                  val insert : t -> graph -> graph
                  val update : t -> label -> graph -> graph
                  val remove : t -> graph -> graph
                  val has_edge : t -> t -> graph -> bool
                  val edge : t -> t -> graph -> edge option
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val comparator :
                    (t, comparator_witness) Base__.Comparator.comparator
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = node
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (node, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : node -> '-> 'a t
                          val of_alist :
                            (node * 'a) list ->
                            [ `Duplicate_key of node | `Ok of 'a t ]
                          val of_alist_or_error :
                            (node * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (node * 'a) list -> 'a t
                          val of_alist_multi : (node * 'a) list -> 'a list t
                          val of_alist_fold :
                            (node * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (node * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (node * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> node * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of node | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            node Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:node -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:node -> data:'-> 'a list t
                          val remove_multi : 'a list t -> node -> 'a list t
                          val change :
                            'a t ->
                            node -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> node -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> node -> 'a option
                          val find_exn : 'a t -> node -> 'a
                          val remove : 'a t -> node -> 'a t
                          val mem : 'a t -> node -> bool
                          val iter_keys : 'a t -> f:(node -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:node -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:node ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:node -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:node -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:node ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:node -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:node -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:node ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:node -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> node list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (node * 'a) list
                          val validate :
                            name:(node -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:node ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (node, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (node * 'a) option
                          val min_elt_exn : 'a t -> node * 'a
                          val max_elt : 'a t -> (node * 'a) option
                          val max_elt_exn : 'a t -> node * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:node -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:node -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:node -> data:'-> bool) -> int
                          val split :
                            'a t -> node -> 'a t * (node * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:node Base__.Maybe_bound.t ->
                            upper_bound:node Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:node ->
                            max:node ->
                            init:'->
                            f:(key:node -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:node -> max:node -> (node * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> node -> (node * 'a) option
                          val nth : 'a t -> int -> (node * 'a) option
                          val nth_exn : 'a t -> int -> node * 'a
                          val rank : 'a t -> node -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:node ->
                            ?keys_less_or_equal_to:node ->
                            'a t -> (node * 'a) Base__.Sequence.t
                          val obs :
                            node Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            node Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (node, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : node -> '-> 'a t
                      val of_alist :
                        (node * 'a) list ->
                        [ `Duplicate_key of node | `Ok of 'a t ]
                      val of_alist_or_error :
                        (node * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (node * 'a) list -> 'a t
                      val of_alist_multi : (node * 'a) list -> 'a list t
                      val of_alist_fold :
                        (node * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (node * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (node * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of node | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:node -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:node -> data:'-> 'a list t
                      val remove_multi : 'a list t -> node -> 'a list t
                      val change :
                        'a t -> node -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> node -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> node -> 'a option
                      val find_exn : 'a t -> node -> 'a
                      val remove : 'a t -> node -> 'a t
                      val mem : 'a t -> node -> bool
                      val iter_keys : 'a t -> f:(node -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:node -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:node -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:node -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:node -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> node list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (node * 'a) list
                      val validate :
                        name:(node -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (node, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (node * 'a) option
                      val min_elt_exn : 'a t -> node * 'a
                      val max_elt : 'a t -> (node * 'a) option
                      val max_elt_exn : 'a t -> node * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:node -> data:'-> bool) -> int
                      val split :
                        'a t -> node -> 'a t * (node * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:node Base__.Maybe_bound.t ->
                        upper_bound:node Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:node ->
                        max:node ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:node -> max:node -> (node * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> node -> (node * 'a) option
                      val nth : 'a t -> int -> (node * 'a) option
                      val nth_exn : 'a t -> int -> node * 'a
                      val rank : 'a t -> node -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:node ->
                        ?keys_less_or_equal_to:node ->
                        'a t -> (node * 'a) Base__.Sequence.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> node
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : node Bin_prot.Type_class.t
                                   val bin_read_t : node Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> node)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     node Bin_prot.Type_class.reader
                                   val bin_size_t : node Bin_prot.Size.sizer
                                   val bin_write_t :
                                     node Bin_prot.Write.writer
                                   val bin_writer_t :
                                     node Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     node -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = node
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (node, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(node -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> node -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(node -> bool) -> bool
                          val for_all : t -> f:(node -> bool) -> bool
                          val count : t -> f:(node -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(node -> 'sum) -> 'sum
                          val find : t -> f:(node -> bool) -> node option
                          val find_map :
                            t -> f:(node -> 'a option) -> 'a option
                          val to_list : t -> node list
                          val to_array : t -> node array
                          val invariants : t -> bool
                          val mem : t -> node -> bool
                          val add : t -> node -> t
                          val remove : t -> node -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t ->
                            (node, node) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               node ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(node -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of node * node
                               | `Left of node
                               | `Right of node ] -> unit) ->
                            unit
                          val filter : t -> f:(node -> bool) -> t
                          val partition_tf : t -> f:(node -> bool) -> t * t
                          val elements : t -> node list
                          val min_elt : t -> node option
                          val min_elt_exn : t -> node
                          val max_elt : t -> node option
                          val max_elt_exn : t -> node
                          val choose : t -> node option
                          val choose_exn : t -> node
                          val split : t -> node -> t * node option * t
                          val group_by :
                            t -> equiv:(node -> node -> bool) -> t list
                          val find_exn : t -> f:(node -> bool) -> node
                          val find_index : t -> int -> node option
                          val nth : t -> int -> node option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:node ->
                            ?less_or_equal_to:node ->
                            t -> node Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:node ->
                            ?less_or_equal_to:node ->
                            t ->
                            t ->
                            (node, node)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(node -> 'data) ->
                            (node, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            node Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            node Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : node -> t
                          val union_list : t list -> t
                          val of_list : node list -> t
                          val of_array : node array -> t
                          val of_sorted_array :
                            node array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : node array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> node) -> t
                          val stable_dedup_list : node list -> node list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> node) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> node option) -> t
                          val of_tree : t -> t
                          val of_hash_set :
                            node Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (node, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            node Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> node
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (node, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(node -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(node -> bool) -> bool
                      val for_all : t -> f:(node -> bool) -> bool
                      val count : t -> f:(node -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(node -> 'sum) -> 'sum
                      val find : t -> f:(node -> bool) -> node option
                      val find_map : t -> f:(node -> 'a option) -> 'a option
                      val to_list : t -> node list
                      val to_array : t -> node array
                      val invariants : t -> bool
                      val mem : t -> node -> bool
                      val add : t -> node -> t
                      val remove : t -> node -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (node, node) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           node ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(node -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of node * node
                           | `Left of node
                           | `Right of node ] -> unit) ->
                        unit
                      val filter : t -> f:(node -> bool) -> t
                      val partition_tf : t -> f:(node -> bool) -> t * t
                      val elements : t -> node list
                      val min_elt : t -> node option
                      val min_elt_exn : t -> node
                      val max_elt : t -> node option
                      val max_elt_exn : t -> node
                      val choose : t -> node option
                      val choose_exn : t -> node
                      val split : t -> node -> t * node option * t
                      val group_by :
                        t -> equiv:(node -> node -> bool) -> t list
                      val find_exn : t -> f:(node -> bool) -> node
                      val find_index : t -> int -> node option
                      val nth : t -> int -> node option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node ->
                        t ->
                        t ->
                        (node, node)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(node -> 'data) ->
                        (node, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : node -> t
                      val union_list : t list -> t
                      val of_list : node list -> t
                      val of_array : node array -> t
                      val of_sorted_array : node array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : node array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node) -> t
                      val stable_dedup_list : node list -> node list
                      val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : node Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (node, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> node
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : node Bin_prot.Type_class.t
                                   val bin_read_t : node Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> node)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     node Bin_prot.Type_class.reader
                                   val bin_size_t : node Bin_prot.Size.sizer
                                   val bin_write_t :
                                     node Bin_prot.Write.writer
                                   val bin_writer_t :
                                     node Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     node -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val compare : t -> t -> Core_kernel__.Import.int
                  val hashable :
                    t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = node
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> node -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> node -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> node -> 'a
                      val enqueue :
                        'a t -> node -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> node -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> node -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (node * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> node Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (node * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> node * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> node -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> node -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> node -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:node -> data:'-> 'b) -> 'b
                    end
                  val to_string : t -> Trie.String.Suffix.key
                  val str : unit -> t -> Trie.String.Suffix.key
                  val pps : unit -> t -> Trie.String.Suffix.key
                  val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                  val pp_seq : Format.formatter -> t Seq.t -> unit
                  val pp : Base__.Import.Caml.Format.formatter -> t -> unit
                end
              val empty : t
              val nodes : t -> node Regular.Std.seq
              val edges : t -> edge Regular.Std.seq
              val is_directed : bool
              val number_of_edges : t -> int
              val number_of_nodes : t -> int
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = Node.graph
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (Key.t, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : Key.t -> '-> 'a t
                      val of_alist :
                        (Key.t * 'a) list ->
                        [ `Duplicate_key of Key.t | `Ok of 'a t ]
                      val of_alist_or_error :
                        (Key.t * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (Key.t * 'a) list -> 'a t
                      val of_alist_multi : (Key.t * 'a) list -> 'a list t
                      val of_alist_fold :
                        (Key.t * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (Key.t * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (Key.t * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Key.t * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of Key.t | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        Key.t Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:Key.t -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:Key.t -> data:'-> 'a list t
                      val remove_multi : 'a list t -> Key.t -> 'a list t
                      val change :
                        'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> Key.t -> 'a option
                      val find_exn : 'a t -> Key.t -> 'a
                      val remove : 'a t -> Key.t -> 'a t
                      val mem : 'a t -> Key.t -> bool
                      val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:Key.t ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> Key.t list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (Key.t * 'a) list
                      val validate :
                        name:(Key.t -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (Key.t, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (Key.t * 'a) option
                      val min_elt_exn : 'a t -> Key.t * 'a
                      val max_elt : 'a t -> (Key.t * 'a) option
                      val max_elt_exn : 'a t -> Key.t * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> int
                      val split :
                        'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:Key.t Base__.Maybe_bound.t ->
                        upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:Key.t ->
                        max:Key.t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> Key.t -> (Key.t * 'a) option
                      val nth : 'a t -> int -> (Key.t * 'a) option
                      val nth_exn : 'a t -> int -> Key.t * 'a
                      val rank : 'a t -> Key.t -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:Key.t ->
                        ?keys_less_or_equal_to:Key.t ->
                        'a t -> (Key.t * 'a) Base__.Sequence.t
                      val obs :
                        Key.t Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : Key.t Bin_prot.Type_class.t
                               val bin_read_t : Key.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Key.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Key.t Bin_prot.Type_class.reader
                               val bin_size_t : Key.t Bin_prot.Size.sizer
                               val bin_write_t : Key.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Key.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Key.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = Node.graph
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (Elt.t, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(Elt.t -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(Elt.t -> bool) -> bool
                      val for_all : t -> f:(Elt.t -> bool) -> bool
                      val count : t -> f:(Elt.t -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(Elt.t -> 'sum) -> 'sum
                      val find : t -> f:(Elt.t -> bool) -> Elt.t option
                      val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                      val to_list : t -> Elt.t list
                      val to_array : t -> Elt.t array
                      val invariants : t -> bool
                      val mem : t -> Elt.t -> bool
                      val add : t -> Elt.t -> t
                      val remove : t -> Elt.t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           Elt.t ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of Elt.t * Elt.t
                           | `Left of Elt.t
                           | `Right of Elt.t ] -> unit) ->
                        unit
                      val filter : t -> f:(Elt.t -> bool) -> t
                      val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                      val elements : t -> Elt.t list
                      val min_elt : t -> Elt.t option
                      val min_elt_exn : t -> Elt.t
                      val max_elt : t -> Elt.t option
                      val max_elt_exn : t -> Elt.t
                      val choose : t -> Elt.t option
                      val choose_exn : t -> Elt.t
                      val split : t -> Elt.t -> t * Elt.t option * t
                      val group_by :
                        t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                      val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                      val find_index : t -> int -> Elt.t option
                      val nth : t -> int -> Elt.t option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t -> Elt.t Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t ->
                        t ->
                        (Elt.t, Elt.t)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(Elt.t -> 'data) ->
                        (Elt.t, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        Elt.t Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : Elt.t -> t
                      val union_list : t list -> t
                      val of_list : Elt.t list -> t
                      val of_array : Elt.t array -> t
                      val of_sorted_array :
                        Elt.t array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : Elt.t array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Elt.t) -> t
                      val stable_dedup_list : Elt.t list -> Elt.t list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t option) -> t
                      val of_tree : t -> t
                      val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (Elt.t, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        Elt.t Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (Elt.t, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : Elt.t Bin_prot.Type_class.t
                               val bin_read_t : Elt.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Elt.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Elt.t Bin_prot.Type_class.reader
                               val bin_size_t : Elt.t Bin_prot.Size.sizer
                               val bin_write_t : Elt.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Elt.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Elt.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              val hash : t -> Core_kernel__.Import.int
              val compare : t -> t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = Hash_set.elt
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> Key.t -> 'a
                  val enqueue :
                    'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> Key.t Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> Key.t * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
                  val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                end
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
            end
          module Tid :
            sig
              type t
              type node = tid
              type edge
              module Node :
                sig
                  type t = node
                  type graph = t
                  type label = t
                  type edge = edge
                  val create : label -> label
                  val label : label -> label
                  val mem : label -> graph -> bool
                  val succs : label -> graph -> label Regular.Std.seq
                  val preds : label -> graph -> label Regular.Std.seq
                  val inputs : label -> graph -> edge Regular.Std.seq
                  val outputs : label -> graph -> edge Regular.Std.seq
                  val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
                  val insert : label -> graph -> graph
                  val update : label -> label -> graph -> graph
                  val remove : label -> graph -> graph
                  val has_edge : label -> label -> graph -> bool
                  val edge : label -> label -> graph -> edge option
                  val ( >= ) : label -> label -> bool
                  val ( <= ) : label -> label -> bool
                  val ( = ) : label -> label -> bool
                  val ( > ) : label -> label -> bool
                  val ( < ) : label -> label -> bool
                  val ( <> ) : label -> label -> bool
                  val equal : label -> label -> bool
                  val min : label -> label -> label
                  val max : label -> label -> label
                  val ascending : label -> label -> int
                  val descending : label -> label -> int
                  val between : label -> low:label -> high:label -> bool
                  val clamp_exn : label -> min:label -> max:label -> label
                  val clamp :
                    label ->
                    min:label -> max:label -> label Base__.Or_error.t
                  type comparator_witness
                  val comparator :
                    (label, comparator_witness) Base__.Comparator.comparator
                  val validate_lbound :
                    min:label Base__.Maybe_bound.t ->
                    label Base__.Validate.check
                  val validate_ubound :
                    max:label Base__.Maybe_bound.t ->
                    label Base__.Validate.check
                  val validate_bound :
                    min:label Base__.Maybe_bound.t ->
                    max:label Base__.Maybe_bound.t ->
                    label Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : label -> label -> bool
                      val ( <= ) : label -> label -> bool
                      val ( = ) : label -> label -> bool
                      val ( > ) : label -> label -> bool
                      val ( < ) : label -> label -> bool
                      val ( <> ) : label -> label -> bool
                      val equal : label -> label -> bool
                      val compare : label -> label -> int
                      val min : label -> label -> label
                      val max : label -> label -> label
                    end
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = label
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (label, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : label -> '-> 'a t
                          val of_alist :
                            (label * 'a) list ->
                            [ `Duplicate_key of label | `Ok of 'a t ]
                          val of_alist_or_error :
                            (label * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (label * 'a) list -> 'a t
                          val of_alist_multi : (label * 'a) list -> 'a list t
                          val of_alist_fold :
                            (label * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (label * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (label * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> label * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of label | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            label Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:label -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:label -> data:'-> 'a list t
                          val remove_multi : 'a list t -> label -> 'a list t
                          val change :
                            'a t ->
                            label -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> label -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> label -> 'a option
                          val find_exn : 'a t -> label -> 'a
                          val remove : 'a t -> label -> 'a t
                          val mem : 'a t -> label -> bool
                          val iter_keys : 'a t -> f:(label -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:label -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:label ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:label -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:label -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:label ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:label -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:label -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:label ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:label -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> label list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (label * 'a) list
                          val validate :
                            name:(label -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:label ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (label, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (label * 'a) option
                          val min_elt_exn : 'a t -> label * 'a
                          val max_elt : 'a t -> (label * 'a) option
                          val max_elt_exn : 'a t -> label * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:label -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:label -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:label -> data:'-> bool) -> int
                          val split :
                            'a t ->
                            label -> 'a t * (label * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:label Base__.Maybe_bound.t ->
                            upper_bound:label Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:label ->
                            max:label ->
                            init:'->
                            f:(key:label -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t ->
                            min:label -> max:label -> (label * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> label -> (label * 'a) option
                          val nth : 'a t -> int -> (label * 'a) option
                          val nth_exn : 'a t -> int -> label * 'a
                          val rank : 'a t -> label -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:label ->
                            ?keys_less_or_equal_to:label ->
                            'a t -> (label * 'a) Base__.Sequence.t
                          val obs :
                            label Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            label Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> label
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (label, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : label -> '-> 'a t
                      val of_alist :
                        (label * 'a) list ->
                        [ `Duplicate_key of label | `Ok of 'a t ]
                      val of_alist_or_error :
                        (label * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (label * 'a) list -> 'a t
                      val of_alist_multi : (label * 'a) list -> 'a list t
                      val of_alist_fold :
                        (label * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (label * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (label * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> label * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of label | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        label Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:label -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:label -> data:'-> 'a list t
                      val remove_multi : 'a list t -> label -> 'a list t
                      val change :
                        'a t -> label -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> label -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> label -> 'a option
                      val find_exn : 'a t -> label -> 'a
                      val remove : 'a t -> label -> 'a t
                      val mem : 'a t -> label -> bool
                      val iter_keys : 'a t -> f:(label -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:label -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:label ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:label ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:label -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:label -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:label ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:label -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> label list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (label * 'a) list
                      val validate :
                        name:(label -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:label ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (label, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (label * 'a) option
                      val min_elt_exn : 'a t -> label * 'a
                      val max_elt : 'a t -> (label * 'a) option
                      val max_elt_exn : 'a t -> label * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:label -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:label -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:label -> data:'-> bool) -> int
                      val split :
                        'a t -> label -> 'a t * (label * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:label Base__.Maybe_bound.t ->
                        upper_bound:label Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:label ->
                        max:label ->
                        init:'-> f:(key:label -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:label -> max:label -> (label * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> label -> (label * 'a) option
                      val nth : 'a t -> int -> (label * 'a) option
                      val nth_exn : 'a t -> int -> label * 'a
                      val rank : 'a t -> label -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:label ->
                        ?keys_less_or_equal_to:label ->
                        'a t -> (label * 'a) Base__.Sequence.t
                      val obs :
                        label Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        label Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> label
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : label Bin_prot.Type_class.t
                                   val bin_read_t :
                                     label Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> label)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     label Bin_prot.Type_class.reader
                                   val bin_size_t : label Bin_prot.Size.sizer
                                   val bin_write_t :
                                     label Bin_prot.Write.writer
                                   val bin_writer_t :
                                     label Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     label -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = label
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (label, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(label -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> label -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum ->
                               label -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(label -> bool) -> bool
                          val for_all : t -> f:(label -> bool) -> bool
                          val count : t -> f:(label -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(label -> 'sum) -> 'sum
                          val find : t -> f:(label -> bool) -> label option
                          val find_map :
                            t -> f:(label -> 'a option) -> 'a option
                          val to_list : t -> label list
                          val to_array : t -> label array
                          val invariants : t -> bool
                          val mem : t -> label -> bool
                          val add : t -> label -> t
                          val remove : t -> label -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t ->
                            (label, label) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               label ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(label -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of label * label
                               | `Left of label
                               | `Right of label ] -> unit) ->
                            unit
                          val filter : t -> f:(label -> bool) -> t
                          val partition_tf : t -> f:(label -> bool) -> t * t
                          val elements : t -> label list
                          val min_elt : t -> label option
                          val min_elt_exn : t -> label
                          val max_elt : t -> label option
                          val max_elt_exn : t -> label
                          val choose : t -> label option
                          val choose_exn : t -> label
                          val split : t -> label -> t * label option * t
                          val group_by :
                            t -> equiv:(label -> label -> bool) -> t list
                          val find_exn : t -> f:(label -> bool) -> label
                          val find_index : t -> int -> label option
                          val nth : t -> int -> label option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:label ->
                            ?less_or_equal_to:label ->
                            t -> label Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:label ->
                            ?less_or_equal_to:label ->
                            t ->
                            t ->
                            (label, label)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(label -> 'data) ->
                            (label, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            label Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            label Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : label -> t
                          val union_list : t list -> t
                          val of_list : label list -> t
                          val of_array : label array -> t
                          val of_sorted_array :
                            label array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : label array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> label) -> t
                          val stable_dedup_list : label list -> label list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> label) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> label option) -> t
                          val of_tree : t -> t
                          val of_hash_set :
                            label Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (label, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (label, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            label Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp :
                                         Sexplib.Sexp.t -> label
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (label, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(label -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> label -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(label -> bool) -> bool
                      val for_all : t -> f:(label -> bool) -> bool
                      val count : t -> f:(label -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(label -> 'sum) -> 'sum
                      val find : t -> f:(label -> bool) -> label option
                      val find_map : t -> f:(label -> 'a option) -> 'a option
                      val to_list : t -> label list
                      val to_array : t -> label array
                      val invariants : t -> bool
                      val mem : t -> label -> bool
                      val add : t -> label -> t
                      val remove : t -> label -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (label, label) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           label ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(label -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of label * label
                           | `Left of label
                           | `Right of label ] -> unit) ->
                        unit
                      val filter : t -> f:(label -> bool) -> t
                      val partition_tf : t -> f:(label -> bool) -> t * t
                      val elements : t -> label list
                      val min_elt : t -> label option
                      val min_elt_exn : t -> label
                      val max_elt : t -> label option
                      val max_elt_exn : t -> label
                      val choose : t -> label option
                      val choose_exn : t -> label
                      val split : t -> label -> t * label option * t
                      val group_by :
                        t -> equiv:(label -> label -> bool) -> t list
                      val find_exn : t -> f:(label -> bool) -> label
                      val find_index : t -> int -> label option
                      val nth : t -> int -> label option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:label ->
                        ?less_or_equal_to:label ->
                        t -> label Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:label ->
                        ?less_or_equal_to:label ->
                        t ->
                        t ->
                        (label, label)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(label -> 'data) ->
                        (label, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        label Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        label Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : label -> t
                      val union_list : t list -> t
                      val of_list : label list -> t
                      val of_array : label array -> t
                      val of_sorted_array :
                        label array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : label array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> label) -> t
                      val stable_dedup_list : label list -> label list
                      val map : ('a, 'b) Base.Set.t -> f:('-> label) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> label option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : label Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (label, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (label, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        label Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> label
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : label Bin_prot.Type_class.t
                                   val bin_read_t :
                                     label Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> label)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     label Bin_prot.Type_class.reader
                                   val bin_size_t : label Bin_prot.Size.sizer
                                   val bin_write_t :
                                     label Bin_prot.Write.writer
                                   val bin_writer_t :
                                     label Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     label -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  val hash : label -> Core_kernel__.Import.int
                  val compare : label -> label -> Core_kernel__.Import.int
                  val hashable :
                    label Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = label
                      type ('a, 'b) hashtbl = ('a, 'b) Ir.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                    end
                  module Hash_set :
                    sig
                      type elt = label
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = label
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> label -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> label -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> label -> 'a
                      val enqueue :
                        'a t -> label -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> label -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> label -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> label -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (label * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> label Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (label * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> label * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> label -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> label -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> label -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> label -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:label -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:label -> data:'-> 'b) -> 'b
                    end
                end
              module Edge :
                sig
                  type t = edge
                  type node = tid
                  type graph = Node.graph
                  type label = node
                  val create : label -> label -> label -> t
                  val label : t -> label
                  val src : t -> label
                  val dst : t -> label
                  val mem : t -> graph -> bool
                  val insert : t -> graph -> graph
                  val update : t -> label -> graph -> graph
                  val remove : t -> graph -> graph
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val min : t -> t -> t
                  val max : t -> t -> t
                  val ascending : t -> t -> int
                  val descending : t -> t -> int
                  val between : t -> low:t -> high:t -> bool
                  val clamp_exn : t -> min:t -> max:t -> t
                  val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                  type comparator_witness
                  val comparator :
                    (t, comparator_witness) Base__.Comparator.comparator
                  val validate_lbound :
                    min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_ubound :
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  val validate_bound :
                    min:t Base__.Maybe_bound.t ->
                    max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                  module Replace_polymorphic_compare :
                    sig
                      val ( >= ) : t -> t -> bool
                      val ( <= ) : t -> t -> bool
                      val ( = ) : t -> t -> bool
                      val ( > ) : t -> t -> bool
                      val ( < ) : t -> t -> bool
                      val ( <> ) : t -> t -> bool
                      val equal : t -> t -> bool
                      val compare : t -> t -> int
                      val min : t -> t -> t
                      val max : t -> t -> t
                    end
                  module Map :
                    sig
                      module Key :
                        sig
                          type t = edge
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness = comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type 'a t =
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_map_intf.Tree.t
                          val empty : 'a t
                          val singleton : edge -> '-> 'a t
                          val of_alist :
                            (edge * 'a) list ->
                            [ `Duplicate_key of edge | `Ok of 'a t ]
                          val of_alist_or_error :
                            (edge * 'a) list -> 'a t Base__.Or_error.t
                          val of_alist_exn : (edge * 'a) list -> 'a t
                          val of_alist_multi : (edge * 'a) list -> 'a list t
                          val of_alist_fold :
                            (edge * 'a) list ->
                            init:'-> f:('-> '-> 'b) -> 'b t
                          val of_alist_reduce :
                            (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                          val of_sorted_array :
                            (edge * 'a) array -> 'a t Base__.Or_error.t
                          val of_sorted_array_unchecked :
                            (edge * 'a) array -> 'a t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> edge * 'a) -> 'a t
                          val of_iteri :
                            iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                            [ `Duplicate_key of edge | `Ok of 'v t ]
                          val of_tree : 'a t -> 'a t
                          val of_hashtbl_exn :
                            (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                          val gen :
                            edge Core_kernel__.Quickcheck.Generator.t ->
                            'Core_kernel__.Quickcheck.Generator.t ->
                            'a t Core_kernel__.Quickcheck.Generator.t
                          val invariants : 'a t -> bool
                          val is_empty : 'a t -> bool
                          val length : 'a t -> int
                          val add : 'a t -> key:edge -> data:'-> 'a t
                          val add_multi :
                            'a list t -> key:edge -> data:'-> 'a list t
                          val remove_multi : 'a list t -> edge -> 'a list t
                          val change :
                            'a t ->
                            edge -> f:('a option -> 'a option) -> 'a t
                          val update :
                            'a t -> edge -> f:('a option -> 'a) -> 'a t
                          val find : 'a t -> edge -> 'a option
                          val find_exn : 'a t -> edge -> 'a
                          val remove : 'a t -> edge -> 'a t
                          val mem : 'a t -> edge -> bool
                          val iter_keys : 'a t -> f:(edge -> unit) -> unit
                          val iter : 'a t -> f:('-> unit) -> unit
                          val iteri :
                            'a t -> f:(key:edge -> data:'-> unit) -> unit
                          val iter2 :
                            'a t ->
                            'b t ->
                            f:(key:edge ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               unit) ->
                            unit
                          val map : 'a t -> f:('-> 'b) -> 'b t
                          val mapi :
                            'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                          val fold :
                            'a t ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val fold_right :
                            'a t ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val fold2 :
                            'a t ->
                            'b t ->
                            init:'->
                            f:(key:edge ->
                               data:[ `Both of 'a * 'b
                                    | `Left of 'a
                                    | `Right of 'b ] ->
                               '-> 'c) ->
                            'c
                          val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                          val filter : 'a t -> f:('-> bool) -> 'a t
                          val filteri :
                            'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                          val filter_map :
                            'a t -> f:('-> 'b option) -> 'b t
                          val filter_mapi :
                            'a t ->
                            f:(key:edge -> data:'-> 'b option) -> 'b t
                          val partition_mapi :
                            'a t ->
                            f:(key:edge ->
                               data:'-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partition_map :
                            'a t ->
                            f:('-> [ `Fst of '| `Snd of 'c ]) ->
                            'b t * 'c t
                          val partitioni_tf :
                            'a t ->
                            f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                          val partition_tf :
                            'a t -> f:('-> bool) -> 'a t * 'a t
                          val compare_direct :
                            ('-> '-> int) -> 'a t -> 'a t -> int
                          val equal :
                            ('-> '-> bool) -> 'a t -> 'a t -> bool
                          val keys : 'a t -> edge list
                          val data : 'a t -> 'a list
                          val to_alist :
                            ?key_order:[ `Decreasing | `Increasing ] ->
                            'a t -> (edge * 'a) list
                          val validate :
                            name:(edge -> Trie.String.Suffix.key) ->
                            'Base__.Validate.check ->
                            'a t Base__.Validate.check
                          val merge :
                            'a t ->
                            'b t ->
                            f:(key:edge ->
                               [ `Both of 'a * 'b
                               | `Left of 'a
                               | `Right of 'b ] -> 'c option) ->
                            'c t
                          val symmetric_diff :
                            'a t ->
                            'a t ->
                            data_equal:('-> '-> bool) ->
                            (edge, 'a)
                            Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                            Base__.Sequence.t
                          val min_elt : 'a t -> (edge * 'a) option
                          val min_elt_exn : 'a t -> edge * 'a
                          val max_elt : 'a t -> (edge * 'a) option
                          val max_elt_exn : 'a t -> edge * 'a
                          val for_all : 'a t -> f:('-> bool) -> bool
                          val for_alli :
                            'a t -> f:(key:edge -> data:'-> bool) -> bool
                          val exists : 'a t -> f:('-> bool) -> bool
                          val existsi :
                            'a t -> f:(key:edge -> data:'-> bool) -> bool
                          val count : 'a t -> f:('-> bool) -> int
                          val counti :
                            'a t -> f:(key:edge -> data:'-> bool) -> int
                          val split :
                            'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                          val append :
                            lower_part:'a t ->
                            upper_part:'a t ->
                            [ `Ok of 'a t | `Overlapping_key_ranges ]
                          val subrange :
                            'a t ->
                            lower_bound:edge Base__.Maybe_bound.t ->
                            upper_bound:edge Base__.Maybe_bound.t -> 'a t
                          val fold_range_inclusive :
                            'a t ->
                            min:edge ->
                            max:edge ->
                            init:'->
                            f:(key:edge -> data:'-> '-> 'b) -> 'b
                          val range_to_alist :
                            'a t -> min:edge -> max:edge -> (edge * 'a) list
                          val closest_key :
                            'a t ->
                            [ `Greater_or_equal_to
                            | `Greater_than
                            | `Less_or_equal_to
                            | `Less_than ] -> edge -> (edge * 'a) option
                          val nth : 'a t -> int -> (edge * 'a) option
                          val nth_exn : 'a t -> int -> edge * 'a
                          val rank : 'a t -> edge -> int option
                          val to_tree : 'a t -> 'a t
                          val to_sequence :
                            ?order:[ `Decreasing_key | `Increasing_key ] ->
                            ?keys_greater_or_equal_to:edge ->
                            ?keys_less_or_equal_to:edge ->
                            'a t -> (edge * 'a) Base__.Sequence.t
                          val obs :
                            edge Core_kernel__.Quickcheck.Observer.t ->
                            'Core_kernel__.Quickcheck.Observer.t ->
                            'v t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            edge Core_kernel__.Quickcheck.Shrinker.t ->
                            'Core_kernel__.Quickcheck.Shrinker.t ->
                            'v t Core_kernel__.Quickcheck.Shrinker.t
                          module Provide_of_sexp :
                            functor
                              (K : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                              sig
                                val t_of_sexp :
                                  (Sexplib.Sexp.t -> 'v_x__017_) ->
                                  Sexplib.Sexp.t -> 'v_x__017_ t
                              end
                          val t_of_sexp :
                            (Base__.Sexplib.Sexp.t -> 'a) ->
                            Base__.Sexplib.Sexp.t -> 'a t
                          val sexp_of_t :
                            ('-> Base__.Sexplib.Sexp.t) ->
                            'a t -> Base__.Sexplib.Sexp.t
                        end
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Map.t
                      val compare :
                        ('-> '-> Core_kernel__.Import.int) ->
                        'a t -> 'a t -> Core_kernel__.Import.int
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'Tree.t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__018_) ->
                              Sexplib.Sexp.t -> 'v_x__018_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : edge Bin_prot.Type_class.t
                                   val bin_read_t : edge Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> edge)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     edge Bin_prot.Type_class.reader
                                   val bin_size_t : edge Bin_prot.Size.sizer
                                   val bin_write_t :
                                     edge Bin_prot.Write.writer
                                   val bin_writer_t :
                                     edge Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                            val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                            val bin_write_t :
                              ('a, 'a t) Bin_prot.Write.writer1
                            val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                            val __bin_read_t__ :
                              ('a, int -> 'a t) Bin_prot.Read.reader1
                            val bin_writer_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.writer
                            val bin_reader_t :
                              ('a, 'a t) Bin_prot.Type_class.S1.reader
                            val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                          end
                      module Provide_hash :
                        functor
                          (Key : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     edge -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              (Ppx_hash_lib.Std.Hash.state ->
                               '-> Ppx_hash_lib.Std.Hash.state) ->
                              Ppx_hash_lib.Std.Hash.state ->
                              'a t -> Ppx_hash_lib.Std.Hash.state
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  module Set :
                    sig
                      module Elt :
                        sig
                          type t = edge
                          val t_of_sexp : Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Sexplib.Sexp.t
                          type comparator_witness =
                              Map.Key.comparator_witness
                          val comparator :
                            (t, comparator_witness)
                            Core_kernel__.Comparator.comparator
                        end
                      module Tree :
                        sig
                          type t =
                              (edge, comparator_witness)
                              Core_kernel__.Core_set_intf.Tree.t
                          val compare : t -> t -> Core_kernel__.Import.int
                          val length : t -> int
                          val is_empty : t -> bool
                          val iter : t -> f:(edge -> unit) -> unit
                          val fold :
                            t ->
                            init:'accum ->
                            f:('accum -> edge -> 'accum) -> 'accum
                          val fold_result :
                            t ->
                            init:'accum ->
                            f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                            ('accum, 'e) Base__.Result.t
                          val exists : t -> f:(edge -> bool) -> bool
                          val for_all : t -> f:(edge -> bool) -> bool
                          val count : t -> f:(edge -> bool) -> int
                          val sum :
                            (module Base__.Commutative_group.S with type t = 'sum) ->
                            t -> f:(edge -> 'sum) -> 'sum
                          val find : t -> f:(edge -> bool) -> edge option
                          val find_map :
                            t -> f:(edge -> 'a option) -> 'a option
                          val to_list : t -> edge list
                          val to_array : t -> edge array
                          val invariants : t -> bool
                          val mem : t -> edge -> bool
                          val add : t -> edge -> t
                          val remove : t -> edge -> t
                          val union : t -> t -> t
                          val inter : t -> t -> t
                          val diff : t -> t -> t
                          val symmetric_diff :
                            t ->
                            t ->
                            (edge, edge) Base__.Either.t Base__.Sequence.t
                          val compare_direct : t -> t -> int
                          val equal : t -> t -> bool
                          val is_subset : t -> of_:t -> bool
                          val subset : t -> t -> bool
                          val fold_until :
                            t ->
                            init:'->
                            f:('->
                               edge ->
                               ('b, 'stop)
                               Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                            ('b, 'stop)
                            Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                          val fold_right :
                            t -> init:'-> f:(edge -> '-> 'b) -> 'b
                          val iter2 :
                            t ->
                            t ->
                            f:([ `Both of edge * edge
                               | `Left of edge
                               | `Right of edge ] -> unit) ->
                            unit
                          val filter : t -> f:(edge -> bool) -> t
                          val partition_tf : t -> f:(edge -> bool) -> t * t
                          val elements : t -> edge list
                          val min_elt : t -> edge option
                          val min_elt_exn : t -> edge
                          val max_elt : t -> edge option
                          val max_elt_exn : t -> edge
                          val choose : t -> edge option
                          val choose_exn : t -> edge
                          val split : t -> edge -> t * edge option * t
                          val group_by :
                            t -> equiv:(edge -> edge -> bool) -> t list
                          val find_exn : t -> f:(edge -> bool) -> edge
                          val find_index : t -> int -> edge option
                          val nth : t -> int -> edge option
                          val remove_index : t -> int -> t
                          val to_tree : t -> t
                          val to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:edge ->
                            ?less_or_equal_to:edge ->
                            t -> edge Base__.Sequence.t
                          val merge_to_sequence :
                            ?order:[ `Decreasing | `Increasing ] ->
                            ?greater_or_equal_to:edge ->
                            ?less_or_equal_to:edge ->
                            t ->
                            t ->
                            (edge, edge)
                            Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                            Base__.Sequence.t
                          val to_map :
                            t ->
                            f:(edge -> 'data) ->
                            (edge, 'data, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t
                          val obs :
                            edge Core_kernel__.Quickcheck.Observer.t ->
                            t Core_kernel__.Quickcheck.Observer.t
                          val shrinker :
                            edge Core_kernel__.Quickcheck.Shrinker.t ->
                            t Core_kernel__.Quickcheck.Shrinker.t
                          val empty : t
                          val singleton : edge -> t
                          val union_list : t list -> t
                          val of_list : edge list -> t
                          val of_array : edge array -> t
                          val of_sorted_array :
                            edge array -> t Base__.Or_error.t
                          val of_sorted_array_unchecked : edge array -> t
                          val of_increasing_iterator_unchecked :
                            len:int -> f:(int -> edge) -> t
                          val stable_dedup_list : edge list -> edge list
                          val map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> edge) -> t
                          val filter_map :
                            ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                            f:('-> edge option) -> t
                          val of_tree : t -> t
                          val of_hash_set :
                            edge Core_kernel__.Hash_set.t -> t
                          val of_hashtbl_keys :
                            (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                          val of_map_keys :
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_set_intf.Map.t -> t
                          val gen :
                            edge Core_kernel__.Quickcheck.Generator.t ->
                            t Core_kernel__.Quickcheck.Generator.t
                          module Provide_of_sexp :
                            functor
                              (Elt : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                              sig val t_of_sexp : Sexplib.Sexp.t -> t end
                          val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        end
                      type t = (edge, comparator_witness) Base.Set.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> Tree.t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                      val of_tree : Tree.t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (Elt : sig
                                   val bin_t : edge Bin_prot.Type_class.t
                                   val bin_read_t : edge Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> edge)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     edge Bin_prot.Type_class.reader
                                   val bin_size_t : edge Bin_prot.Size.sizer
                                   val bin_write_t :
                                     edge Bin_prot.Write.writer
                                   val bin_writer_t :
                                     edge Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (int -> t) Bin_prot.Read.reader
                            val bin_shape_t : Bin_prot.Shape.t
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_t : t Bin_prot.Type_class.t
                          end
                      module Provide_hash :
                        functor
                          (Elt : sig
                                   val hash_fold_t :
                                     Base__.Hash.state ->
                                     edge -> Base__.Hash.state
                                 end->
                          sig
                            val hash_fold_t :
                              Ppx_hash_lib.Std.Hash.state ->
                              t -> Ppx_hash_lib.Std.Hash.state
                            val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                          end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  val hash : t -> Core_kernel__.Import.int
                  val compare : t -> t -> Core_kernel__.Import.int
                  val hashable :
                    t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                  module Table :
                    sig
                      type key = t
                      type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                      type 'b t = (key, 'b) hashtbl
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                      type ('a, 'b) t_ = 'b t
                      type 'a key_ = key
                      val hashable :
                        key Core_kernel__.Core_hashtbl_intf.Hashable.t
                      val invariant :
                        'Base__.Invariant_intf.inv ->
                        'a t Base__.Invariant_intf.inv
                      val create :
                        (key, 'b, unit -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_key of key | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_report_all_dups :
                        (key, 'b,
                         (key * 'b) list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_or_error :
                        (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_exn :
                        (key, 'b, (key * 'b) list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val of_alist_multi :
                        (key, 'b list, (key * 'b) list -> 'b list t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_mapped :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'b t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list ->
                         [ `Duplicate_keys of key list | `Ok of 'r t ])
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_or_error :
                        (key, 'r,
                         get_key:('-> key) ->
                         'r list -> 'r t Base__.Or_error.t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val create_with_key_exn :
                        (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val group :
                        (key, 'b,
                         get_key:('-> key) ->
                         get_data:('-> 'b) ->
                         combine:('-> '-> 'b) -> 'r list -> 'b t)
                        Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                      val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                      val clear : 'a t -> unit
                      val copy : 'b t -> 'b t
                      val fold :
                        'b t ->
                        init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                      val iter_keys : 'a t -> f:(key -> unit) -> unit
                      val iter : 'b t -> f:('-> unit) -> unit
                      val iteri :
                        'b t -> f:(key:key -> data:'-> unit) -> unit
                      val iter_vals : 'b t -> f:('-> unit) -> unit
                      val existsi :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val exists : 'b t -> f:('-> bool) -> bool
                      val for_alli :
                        'b t -> f:(key:key -> data:'-> bool) -> bool
                      val for_all : 'b t -> f:('-> bool) -> bool
                      val counti :
                        'b t -> f:(key:key -> data:'-> bool) -> int
                      val count : 'b t -> f:('-> bool) -> int
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val mem : 'a t -> key -> bool
                      val remove : 'a t -> key -> unit
                      val replace : 'b t -> key:key -> data:'-> unit
                      val set : 'b t -> key:key -> data:'-> unit
                      val add :
                        'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                      val add_or_error :
                        'b t -> key:key -> data:'-> unit Base__.Or_error.t
                      val add_exn : 'b t -> key:key -> data:'-> unit
                      val change :
                        'b t -> key -> f:('b option -> 'b option) -> unit
                      val update : 'b t -> key -> f:('b option -> 'b) -> unit
                      val add_multi : 'b list t -> key:key -> data:'-> unit
                      val remove_multi : 'a list t -> key -> unit
                      val map : 'b t -> f:('-> 'c) -> 'c t
                      val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                      val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                      val filter_mapi :
                        'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                      val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                      val filter : 'b t -> f:('-> bool) -> 'b t
                      val filteri :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t
                      val partition_map :
                        'b t ->
                        f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                      val partition_mapi :
                        'b t ->
                        f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                        'c t * 'd t
                      val partition_tf :
                        'b t -> f:('-> bool) -> 'b t * 'b t
                      val partitioni_tf :
                        'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                      val find_or_add :
                        'b t -> key -> default:(unit -> 'b) -> 'b
                      val find : 'b t -> key -> 'b option
                      val find_exn : 'b t -> key -> 'b
                      val find_and_call :
                        'b t ->
                        key ->
                        if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                      val find_and_remove : 'b t -> key -> 'b option
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:key ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      type 'a merge_into_action = Remove | Set_to of 'a
                      val merge_into :
                        src:'a t ->
                        dst:'b t ->
                        f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                        unit
                      val keys : 'a t -> key list
                      val data : 'b t -> 'b list
                      val filter_keys_inplace :
                        'a t -> f:(key -> bool) -> unit
                      val filter_inplace : 'b t -> f:('-> bool) -> unit
                      val filteri_inplace :
                        'b t -> f:(key:key -> data:'-> bool) -> unit
                      val map_inplace : 'b t -> f:('-> 'b) -> unit
                      val mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_map_inplace :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_mapi_inplace :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val replace_all : 'b t -> f:('-> 'b) -> unit
                      val replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b) -> unit
                      val filter_replace_all :
                        'b t -> f:('-> 'b option) -> unit
                      val filter_replace_alli :
                        'b t -> f:(key:key -> data:'-> 'b option) -> unit
                      val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                      val similar :
                        'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                      val to_alist : 'b t -> (key * 'b) list
                      val validate :
                        name:(key -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'b t Base__.Validate.check
                      val incr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      val decr :
                        ?by:int ->
                        ?remove_if_zero:bool -> int t -> key -> unit
                      module Provide_of_sexp :
                        functor
                          (Key : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> key
                                 end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__001_) ->
                              Sexplib.Sexp.t -> 'v_x__001_ t
                          end
                      module Provide_bin_io :
                        functor
                          (Key : sig
                                   val bin_t : key Bin_prot.Type_class.t
                                   val bin_read_t : key Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> key)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     key Bin_prot.Type_class.reader
                                   val bin_size_t : key Bin_prot.Size.sizer
                                   val bin_write_t :
                                     key Bin_prot.Write.writer
                                   val bin_writer_t :
                                     key Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                          sig
                            val bin_t :
                              'Bin_prot.Type_class.t ->
                              'a t Bin_prot.Type_class.t
                            val bin_read_t :
                              'Bin_prot.Read.reader ->
                              'a t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              'Bin_prot.Read.reader ->
                              (Core_kernel__.Import.int -> 'a t)
                              Bin_prot.Read.reader
                            val bin_reader_t :
                              'Bin_prot.Type_class.reader ->
                              'a t Bin_prot.Type_class.reader
                            val bin_size_t :
                              'Bin_prot.Size.sizer ->
                              'a t Bin_prot.Size.sizer
                            val bin_write_t :
                              'Bin_prot.Write.writer ->
                              'a t Bin_prot.Write.writer
                            val bin_writer_t :
                              'Bin_prot.Type_class.writer ->
                              'a t Bin_prot.Type_class.writer
                            val bin_shape_t :
                              Bin_prot.Shape.t -> Bin_prot.Shape.t
                          end
                      val t_of_sexp :
                        (Sexplib.Sexp.t -> 'v_x__002_) ->
                        Sexplib.Sexp.t -> 'v_x__002_ t
                    end
                  module Hash_set :
                    sig
                      type elt = t
                      type t = elt Core_kernel__.Hash_set.t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type 'a t_ = t
                      type 'a elt_ = elt
                      val create :
                        ('a, unit -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      val of_list :
                        ('a, elt list -> t)
                        Core_kernel__.Hash_set_intf.create_options_without_hashable
                      module Provide_of_sexp :
                        functor
                          (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      module Provide_bin_io :
                        functor
                          (X : sig
                                 val bin_t : elt Bin_prot.Type_class.t
                                 val bin_read_t : elt Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> elt)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   elt Bin_prot.Type_class.reader
                                 val bin_size_t : elt Bin_prot.Size.sizer
                                 val bin_write_t : elt Bin_prot.Write.writer
                                 val bin_writer_t :
                                   elt Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                          sig
                            val bin_t : t Bin_prot.Type_class.t
                            val bin_read_t : t Bin_prot.Read.reader
                            val __bin_read_t__ :
                              (Core_kernel__.Import.int -> t)
                              Bin_prot.Read.reader
                            val bin_reader_t : t Bin_prot.Type_class.reader
                            val bin_size_t : t Bin_prot.Size.sizer
                            val bin_write_t : t Bin_prot.Write.writer
                            val bin_writer_t : t Bin_prot.Type_class.writer
                            val bin_shape_t : Bin_prot.Shape.t
                          end
                      val t_of_sexp : Sexplib.Sexp.t -> t
                    end
                  module Hash_queue :
                    sig
                      module Key :
                        sig
                          type t = edge
                          val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          val compare : t -> t -> int
                          val hash : t -> int
                        end
                      type 'a t
                      val sexp_of_t :
                        ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                      val length : 'a t -> int
                      val is_empty : 'a t -> bool
                      val iter : 'a t -> f:('-> unit) -> unit
                      val fold :
                        'a t ->
                        init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                      val fold_result :
                        'a t ->
                        init:'accum ->
                        f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val fold_until :
                        'a t ->
                        init:'accum ->
                        f:('accum ->
                           '->
                           ('accum, 'stop)
                           Base.Container_intf.Continue_or_stop.t) ->
                        ('accum, 'stop)
                        Base.Container_intf.Finished_or_stopped_early.t
                      val exists : 'a t -> f:('-> bool) -> bool
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        'a t -> f:('-> 'sum) -> 'sum
                      val find : 'a t -> f:('-> bool) -> 'a option
                      val find_map : 'a t -> f:('-> 'b option) -> 'b option
                      val to_list : 'a t -> 'a list
                      val to_array : 'a t -> 'a array
                      val min_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val max_elt :
                        'a t -> cmp:('-> '-> int) -> 'a option
                      val invariant : 'a t -> Core_kernel__.Import.unit
                      val create :
                        ?growth_allowed:Core_kernel__.Import.bool ->
                        ?size:Core_kernel__.Import.int ->
                        Core_kernel__.Import.unit -> 'a t
                      val clear : 'a t -> Core_kernel__.Import.unit
                      val mem : 'a t -> edge -> Core_kernel__.Import.bool
                      val lookup :
                        'a t -> edge -> 'Core_kernel__.Import.option
                      val lookup_exn : 'a t -> edge -> 'a
                      val enqueue :
                        'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                      val enqueue_exn :
                        'a t -> edge -> '-> Core_kernel__.Import.unit
                      val lookup_and_move_to_back :
                        'a t -> edge -> 'Core_kernel__.Import.option
                      val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                      val first : 'a t -> 'Core_kernel__.Import.option
                      val first_with_key :
                        'a t -> (edge * 'a) Core_kernel__.Import.option
                      val keys : 'a t -> edge Core_kernel__.Import.list
                      val dequeue : 'a t -> 'Core_kernel__.Import.option
                      val dequeue_exn : 'a t -> 'a
                      val dequeue_with_key :
                        'a t -> (edge * 'a) Core_kernel__.Import.option
                      val dequeue_with_key_exn : 'a t -> edge * 'a
                      val dequeue_all :
                        'a t ->
                        f:('-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                      val remove_exn :
                        'a t -> edge -> Core_kernel__.Import.unit
                      val replace :
                        'a t -> edge -> '-> [ `No_such_key | `Ok ]
                      val replace_exn :
                        'a t -> edge -> '-> Core_kernel__.Import.unit
                      val iteri :
                        'a t ->
                        f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                        Core_kernel__.Import.unit
                      val foldi :
                        'a t ->
                        init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                    end
                end
              val empty : t
              val nodes : t -> node Regular.Std.seq
              val edges : t -> edge Regular.Std.seq
              val is_directed : bool
              val number_of_edges : t -> int
              val number_of_nodes : t -> int
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = Edge.graph
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (Key.t, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : Key.t -> '-> 'a t
                      val of_alist :
                        (Key.t * 'a) list ->
                        [ `Duplicate_key of Key.t | `Ok of 'a t ]
                      val of_alist_or_error :
                        (Key.t * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (Key.t * 'a) list -> 'a t
                      val of_alist_multi : (Key.t * 'a) list -> 'a list t
                      val of_alist_fold :
                        (Key.t * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (Key.t * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (Key.t * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Key.t * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of Key.t | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        Key.t Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:Key.t -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:Key.t -> data:'-> 'a list t
                      val remove_multi : 'a list t -> Key.t -> 'a list t
                      val change :
                        'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> Key.t -> 'a option
                      val find_exn : 'a t -> Key.t -> 'a
                      val remove : 'a t -> Key.t -> 'a t
                      val mem : 'a t -> Key.t -> bool
                      val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:Key.t ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:Key.t ->
                           data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> Key.t list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (Key.t * 'a) list
                      val validate :
                        name:(Key.t -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:Key.t ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (Key.t, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (Key.t * 'a) option
                      val min_elt_exn : 'a t -> Key.t * 'a
                      val max_elt : 'a t -> (Key.t * 'a) option
                      val max_elt_exn : 'a t -> Key.t * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:Key.t -> data:'-> bool) -> int
                      val split :
                        'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:Key.t Base__.Maybe_bound.t ->
                        upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:Key.t ->
                        max:Key.t ->
                        init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> Key.t -> (Key.t * 'a) option
                      val nth : 'a t -> int -> (Key.t * 'a) option
                      val nth_exn : 'a t -> int -> Key.t * 'a
                      val rank : 'a t -> Key.t -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:Key.t ->
                        ?keys_less_or_equal_to:Key.t ->
                        'a t -> (Key.t * 'a) Base__.Sequence.t
                      val obs :
                        Key.t Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : Key.t Bin_prot.Type_class.t
                               val bin_read_t : Key.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Key.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Key.t Bin_prot.Type_class.reader
                               val bin_size_t : Key.t Bin_prot.Size.sizer
                               val bin_write_t : Key.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Key.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Key.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = Edge.graph
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (Elt.t, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(Elt.t -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(Elt.t -> bool) -> bool
                      val for_all : t -> f:(Elt.t -> bool) -> bool
                      val count : t -> f:(Elt.t -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(Elt.t -> 'sum) -> 'sum
                      val find : t -> f:(Elt.t -> bool) -> Elt.t option
                      val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                      val to_list : t -> Elt.t list
                      val to_array : t -> Elt.t array
                      val invariants : t -> bool
                      val mem : t -> Elt.t -> bool
                      val add : t -> Elt.t -> t
                      val remove : t -> Elt.t -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           Elt.t ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of Elt.t * Elt.t
                           | `Left of Elt.t
                           | `Right of Elt.t ] -> unit) ->
                        unit
                      val filter : t -> f:(Elt.t -> bool) -> t
                      val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                      val elements : t -> Elt.t list
                      val min_elt : t -> Elt.t option
                      val min_elt_exn : t -> Elt.t
                      val max_elt : t -> Elt.t option
                      val max_elt_exn : t -> Elt.t
                      val choose : t -> Elt.t option
                      val choose_exn : t -> Elt.t
                      val split : t -> Elt.t -> t * Elt.t option * t
                      val group_by :
                        t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                      val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                      val find_index : t -> int -> Elt.t option
                      val nth : t -> int -> Elt.t option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t -> Elt.t Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:Elt.t ->
                        ?less_or_equal_to:Elt.t ->
                        t ->
                        t ->
                        (Elt.t, Elt.t)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(Elt.t -> 'data) ->
                        (Elt.t, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        Elt.t Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : Elt.t -> t
                      val union_list : t list -> t
                      val of_list : Elt.t list -> t
                      val of_array : Elt.t array -> t
                      val of_sorted_array :
                        Elt.t array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : Elt.t array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> Elt.t) -> t
                      val stable_dedup_list : Elt.t list -> Elt.t list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> Elt.t option) -> t
                      val of_tree : t -> t
                      val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (Elt.t, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        Elt.t Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (Elt.t, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : Elt.t Bin_prot.Type_class.t
                               val bin_read_t : Elt.t Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> Elt.t)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 Elt.t Bin_prot.Type_class.reader
                               val bin_size_t : Elt.t Bin_prot.Size.sizer
                               val bin_write_t : Elt.t Bin_prot.Write.writer
                               val bin_writer_t :
                                 Elt.t Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 Elt.t -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              val hash : t -> Core_kernel__.Import.int
              val compare : t -> t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = Hash_set.elt
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                  val lookup :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> Key.t -> 'a
                  val enqueue :
                    'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> Key.t -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> Key.t Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (Key.t * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> Key.t * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
                  val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> Key.t -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                end
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
            end
        end
      module Disasm :
        sig
          type t = Bap.Std.disasm
          val create : Bap.Std.cfg -> Bap.Std.Disasm.t
          val of_mem :
            ?backend:string ->
            ?brancher:Bap.Std.brancher ->
            ?rooter:Bap.Std.rooter ->
            Bap.Std.arch ->
            Bap.Std.mem -> Bap.Std.Disasm.t Core_kernel.Std.Or_error.t
          val of_image :
            ?backend:string ->
            ?brancher:Bap.Std.brancher ->
            ?rooter:Bap.Std.rooter ->
            Bap.Std.image -> Bap.Std.Disasm.t Core_kernel.Std.Or_error.t
          val of_file :
            ?backend:string ->
            ?brancher:Bap.Std.brancher ->
            ?rooter:Bap.Std.rooter ->
            ?loader:string ->
            string -> Bap.Std.Disasm.t Core_kernel.Std.Or_error.t
          module With_exn :
            sig
              val of_mem :
                ?backend:string ->
                ?brancher:Bap.Std.brancher ->
                ?rooter:Bap.Std.rooter ->
                Bap.Std.arch -> Bap.Std.mem -> Bap.Std.Disasm.t
              val of_image :
                ?backend:string ->
                ?brancher:Bap.Std.brancher ->
                ?rooter:Bap.Std.rooter -> Bap.Std.image -> Bap.Std.Disasm.t
              val of_file :
                ?backend:string ->
                ?brancher:Bap.Std.brancher ->
                ?rooter:Bap.Std.rooter ->
                ?loader:string -> string -> Bap.Std.Disasm.t
            end
          val merge :
            Bap.Std.Disasm.t -> Bap.Std.Disasm.t -> Bap.Std.Disasm.t
          val insns :
            Bap.Std.Disasm.t -> (Bap.Std.mem * Bap.Std.insn) Bap.Std.seq
          val cfg : Bap.Std.Disasm.t -> Bap.Std.cfg
          val insn : Bap.Std.insn Bap.Std.tag
        end
      type symtab
      module Symtab :
        sig
          type t = Bap.Std.symtab
          val sexp_of_t : t -> Sexplib.Sexp.t
          type fn = string * Bap.Std.block * Bap.Std.cfg
          val sexp_of_fn : fn -> Sexplib.Sexp.t
          val empty : Bap.Std.Symtab.t
          val add_symbol :
            Bap.Std.Symtab.t -> Bap.Std.Symtab.fn -> Bap.Std.Symtab.t
          val remove :
            Bap.Std.Symtab.t -> Bap.Std.Symtab.fn -> Bap.Std.Symtab.t
          val find_by_name :
            Bap.Std.Symtab.t -> string -> Bap.Std.Symtab.fn option
          val find_by_start :
            Bap.Std.Symtab.t -> Bap.Std.addr -> Bap.Std.Symtab.fn option
          val owners :
            Bap.Std.Symtab.t -> Bap.Std.addr -> Bap.Std.Symtab.fn list
          val dominators :
            Bap.Std.Symtab.t -> Bap.Std.mem -> Bap.Std.Symtab.fn list
          val intersecting :
            Bap.Std.Symtab.t -> Bap.Std.mem -> Bap.Std.Symtab.fn list
          val to_sequence : Bap.Std.Symtab.t -> Bap.Std.Symtab.fn Bap.Std.seq
          val span : Bap.Std.Symtab.fn -> unit Bap.Std.memmap
        end
      type lifter =
          Bap.Std.mem ->
          Bap.Std.Disasm_expert.Basic.full_insn ->
          Bap.Std.bil Core_kernel.Std.Or_error.t
      module type CPU =
        sig
          val gpr : Bap.Std.Var.Set.t
          val mem : Bap.Std.var
          val sp : Bap.Std.var
          val zf : Bap.Std.var
          val cf : Bap.Std.var
          val vf : Bap.Std.var
          val nf : Bap.Std.var
          val is_reg : Bap.Std.var -> bool
          val is_flag : Bap.Std.var -> bool
          val is_sp : Bap.Std.var -> bool
          val is_bp : Bap.Std.var -> bool
          val is_zf : Bap.Std.var -> bool
          val is_cf : Bap.Std.var -> bool
          val is_vf : Bap.Std.var -> bool
          val is_nf : Bap.Std.var -> bool
          val is_mem : Bap.Std.var -> bool
        end
      module type Target = sig module CPU : CPU val lift : Bap.Std.lifter end
      val target_of_arch : Bap.Std.arch -> (module Bap.Std.Target)
      val register_target : Bap.Std.arch -> (module Bap.Std.Target-> unit
      module Tid :
        sig
          type t = Bap.Std.tid
          val create : unit -> Bap.Std.Tid.t
          val set_name : Bap.Std.tid -> string -> unit
          val name : Bap.Std.tid -> string
          val from_string : string -> Bap.Std.tid Core_kernel.Std.Or_error.t
          val from_string_exn : string -> Bap.Std.tid
          val ( !! ) : string -> Bap.Std.tid
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.tid
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Block.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Term :
        sig
          type 'a t = 'Bap.Std.term
          val clone : 'Bap.Std.Term.t -> 'Bap.Std.Term.t
          val same : 'Bap.Std.Term.t -> 'Bap.Std.Term.t -> bool
          val name : 'Bap.Std.Term.t -> string
          val tid : 'Bap.Std.Term.t -> Bap.Std.tid
          val length : ('a, 'b) Bap.Std.cls -> 'Bap.Std.Term.t -> int
          val find :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t option
          val find_exn :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t
          val update :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> 'Bap.Std.Term.t -> 'Bap.Std.Term.t
          val remove :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t
          val change :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t ->
            Bap.Std.tid ->
            ('Bap.Std.Term.t option -> 'Bap.Std.Term.t option) ->
            'Bap.Std.Term.t
          val enum :
            ?rev:bool ->
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> 'Bap.Std.Term.t Bap.Std.seq
          val to_sequence :
            ?rev:bool ->
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> 'Bap.Std.Term.t Bap.Std.seq
          val map :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t ->
            f:('Bap.Std.Term.t -> 'Bap.Std.Term.t) -> 'Bap.Std.Term.t
          val filter_map :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t ->
            f:('Bap.Std.Term.t -> 'Bap.Std.Term.t option) ->
            'Bap.Std.Term.t
          val concat_map :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t ->
            f:('Bap.Std.Term.t -> 'Bap.Std.Term.t list) ->
            'Bap.Std.Term.t
          val filter :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t ->
            f:('Bap.Std.Term.t -> bool) -> 'Bap.Std.Term.t
          val first :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> 'Bap.Std.Term.t option
          val last :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> 'Bap.Std.Term.t option
          val next :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t option
          val prev :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t option
          val after :
            ('a, 'b) Bap.Std.cls ->
            ?rev:bool ->
            'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t Bap.Std.seq
          val before :
            ('a, 'b) Bap.Std.cls ->
            ?rev:bool ->
            'Bap.Std.Term.t -> Bap.Std.tid -> 'Bap.Std.Term.t Bap.Std.seq
          val append :
            ('a, 'b) Bap.Std.cls ->
            ?after:Bap.Std.tid ->
            'Bap.Std.Term.t -> 'Bap.Std.Term.t -> 'Bap.Std.Term.t
          val prepend :
            ('a, 'b) Bap.Std.cls ->
            ?before:Bap.Std.tid ->
            'Bap.Std.Term.t -> 'Bap.Std.Term.t -> 'Bap.Std.Term.t
          val nth :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> int -> 'Bap.Std.Term.t option
          val nth_exn :
            ('a, 'b) Bap.Std.cls ->
            'Bap.Std.Term.t -> int -> 'Bap.Std.Term.t
          val set_attr :
            'Bap.Std.Term.t -> 'Bap.Std.tag -> '-> 'Bap.Std.Term.t
          val attrs : 'Bap.Std.Term.t -> Bap.Std.Dict.t
          val with_attrs :
            'Bap.Std.Term.t -> Bap.Std.Dict.t -> 'Bap.Std.Term.t
          val get_attr : 'Bap.Std.Term.t -> 'Bap.Std.tag -> 'b option
          val has_attr : 'Bap.Std.Term.t -> 'Bap.Std.tag -> bool
          val del_attr :
            'Bap.Std.Term.t -> 'Bap.Std.tag -> 'Bap.Std.Term.t
          val origin : Bap.Std.tid Bap.Std.tag
          val synthetic : unit Bap.Std.tag
          val live : unit Bap.Std.tag
          val dead : unit Bap.Std.tag
          val visited : unit Bap.Std.tag
          val precondition : Bap.Std.exp Bap.Std.tag
          val invariant : Bap.Std.exp Bap.Std.tag
          val postcondition : Bap.Std.exp Bap.Std.tag
          class mapper :
            object
              val exps_stack : exp list
              val under_condition : bool
              method map_arg :
                Bap.Std.arg Bap.Std.term -> Bap.Std.arg Bap.Std.term
              method map_binop : binop -> Exp.t -> Exp.t -> Exp.t
              method map_blk :
                Bap.Std.blk Bap.Std.term -> Bap.Std.blk Bap.Std.term
              method map_cast : cast -> int -> Exp.t -> Exp.t
              method map_concat : Exp.t -> Exp.t -> Exp.t
              method map_def :
                Bap.Std.def Bap.Std.term -> Bap.Std.def Bap.Std.term
              method map_exp : Exp.t -> Exp.t
              method map_extract : hi:int -> lo:int -> Exp.t -> Exp.t
              method map_int : word -> Exp.t
              method map_ite : cond:Exp.t -> yes:Exp.t -> no:Exp.t -> Exp.t
              method map_jmp :
                Bap.Std.jmp Bap.Std.term -> Bap.Std.jmp Bap.Std.term
              method map_let : var -> exp:Exp.t -> body:Exp.t -> Exp.t
              method map_load :
                mem:Exp.t -> addr:Exp.t -> endian -> size -> Exp.t
              method map_phi :
                Bap.Std.phi Bap.Std.term -> Bap.Std.phi Bap.Std.term
              method map_store :
                mem:Exp.t ->
                addr:Exp.t -> exp:Exp.t -> endian -> size -> Exp.t
              method map_sub :
                Bap.Std.sub Bap.Std.term -> Bap.Std.sub Bap.Std.term
              method map_sym : var -> var
              method map_term :
                ('p, 't) Bap.Std.cls -> 'Bap.Std.term -> 'Bap.Std.term
              method map_unknown : Trie.String.Suffix.key -> typ -> Exp.t
              method map_unop : unop -> Exp.t -> Exp.t
              method map_var : var -> Exp.t
              method run :
                Bap.Std.program Bap.Std.term -> Bap.Std.program Bap.Std.term
            end
          class ['a] visitor :
            object
              val exps_stack : exp list
              val under_condition : bool
              method enter_arg : Bap.Std.arg Bap.Std.term -> '-> 'a
              method enter_binop : binop -> Exp.t -> Exp.t -> '-> 'a
              method enter_blk : Bap.Std.blk Bap.Std.term -> '-> 'a
              method enter_cast : cast -> int -> Exp.t -> '-> 'a
              method enter_concat : Exp.t -> Exp.t -> '-> 'a
              method enter_def : Bap.Std.def Bap.Std.term -> '-> 'a
              method enter_exp : Exp.t -> '-> 'a
              method enter_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
              method enter_int : word -> '-> 'a
              method enter_ite :
                cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
              method enter_jmp : Bap.Std.jmp Bap.Std.term -> '-> 'a
              method enter_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
              method enter_load :
                mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
              method enter_phi : Bap.Std.phi Bap.Std.term -> '-> 'a
              method enter_program : Bap.Std.program Bap.Std.term -> '-> 'a
              method enter_store :
                mem:Exp.t ->
                addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
              method enter_sub : Bap.Std.sub Bap.Std.term -> '-> 'a
              method enter_term :
                ('p, 't) Bap.Std.cls -> 'Bap.Std.term -> '-> 'a
              method enter_unknown :
                Trie.String.Suffix.key -> typ -> '-> 'a
              method enter_unop : unop -> Exp.t -> '-> 'a
              method enter_var : var -> '-> 'a
              method leave_arg : Bap.Std.arg Bap.Std.term -> '-> 'a
              method leave_binop : binop -> Exp.t -> Exp.t -> '-> 'a
              method leave_blk : Bap.Std.blk Bap.Std.term -> '-> 'a
              method leave_cast : cast -> int -> Exp.t -> '-> 'a
              method leave_concat : Exp.t -> Exp.t -> '-> 'a
              method leave_def : Bap.Std.def Bap.Std.term -> '-> 'a
              method leave_exp : Exp.t -> '-> 'a
              method leave_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
              method leave_int : word -> '-> 'a
              method leave_ite :
                cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
              method leave_jmp : Bap.Std.jmp Bap.Std.term -> '-> 'a
              method leave_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
              method leave_load :
                mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
              method leave_phi : Bap.Std.phi Bap.Std.term -> '-> 'a
              method leave_program : Bap.Std.program Bap.Std.term -> '-> 'a
              method leave_store :
                mem:Exp.t ->
                addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
              method leave_sub : Bap.Std.sub Bap.Std.term -> '-> 'a
              method leave_term :
                ('p, 't) Bap.Std.cls -> 'Bap.Std.term -> '-> 'a
              method leave_unknown :
                Trie.String.Suffix.key -> typ -> '-> 'a
              method leave_unop : unop -> Exp.t -> '-> 'a
              method leave_var : var -> '-> 'a
              method run : Bap.Std.program Bap.Std.term -> '-> 'a
              method visit_arg : Bap.Std.arg Bap.Std.term -> '-> 'a
              method visit_binop : binop -> Exp.t -> Exp.t -> '-> 'a
              method visit_blk : Bap.Std.blk Bap.Std.term -> '-> 'a
              method visit_cast : cast -> int -> Exp.t -> '-> 'a
              method visit_concat : Exp.t -> Exp.t -> '-> 'a
              method visit_def : Bap.Std.def Bap.Std.term -> '-> 'a
              method visit_exp : Exp.t -> '-> 'a
              method visit_extract : hi:int -> lo:int -> Exp.t -> '-> 'a
              method visit_int : word -> '-> 'a
              method visit_ite :
                cond:Exp.t -> yes:Exp.t -> no:Exp.t -> '-> 'a
              method visit_jmp : Bap.Std.jmp Bap.Std.term -> '-> 'a
              method visit_let : var -> exp:Exp.t -> body:Exp.t -> '-> 'a
              method visit_load :
                mem:Exp.t -> addr:Exp.t -> endian -> size -> '-> 'a
              method visit_phi : Bap.Std.phi Bap.Std.term -> '-> 'a
              method visit_store :
                mem:Exp.t ->
                addr:Exp.t -> exp:Exp.t -> endian -> size -> '-> 'a
              method visit_sub : Bap.Std.sub Bap.Std.term -> '-> 'a
              method visit_term :
                ('p, 't) Bap.Std.cls -> 'Bap.Std.term -> '-> 'a
              method visit_unknown :
                Trie.String.Suffix.key -> typ -> '-> 'a
              method visit_unop : unop -> Exp.t -> '-> 'a
              method visit_var : var -> '-> 'a
            end
          val switch :
            ('p, 't) Bap.Std.cls ->
            program:(Bap.Std.program Bap.Std.term -> 'a) ->
            sub:(Bap.Std.sub Bap.Std.term -> 'a) ->
            arg:(Bap.Std.arg Bap.Std.term -> 'a) ->
            blk:(Bap.Std.blk Bap.Std.term -> 'a) ->
            phi:(Bap.Std.phi Bap.Std.term -> 'a) ->
            def:(Bap.Std.def Bap.Std.term -> 'a) ->
            jmp:(Bap.Std.jmp Bap.Std.term -> 'a) -> 'Bap.Std.term -> 'a
          val proj :
            ('p, 't) Bap.Std.cls ->
            ?program:(Bap.Std.program Bap.Std.term -> 'a option) ->
            ?sub:(Bap.Std.sub Bap.Std.term -> 'a option) ->
            ?arg:(Bap.Std.arg Bap.Std.term -> 'a option) ->
            ?blk:(Bap.Std.blk Bap.Std.term -> 'a option) ->
            ?phi:(Bap.Std.phi Bap.Std.term -> 'a option) ->
            ?def:(Bap.Std.def Bap.Std.term -> 'a option) ->
            ?jmp:(Bap.Std.jmp Bap.Std.term -> 'a option) ->
            'Bap.Std.term -> 'a option
          val cata :
            ('p, 't) Bap.Std.cls ->
            init:'->
            ?program:(Bap.Std.program Bap.Std.term -> 'a) ->
            ?sub:(Bap.Std.sub Bap.Std.term -> 'a) ->
            ?arg:(Bap.Std.arg Bap.Std.term -> 'a) ->
            ?blk:(Bap.Std.blk Bap.Std.term -> 'a) ->
            ?phi:(Bap.Std.phi Bap.Std.term -> 'a) ->
            ?def:(Bap.Std.def Bap.Std.term -> 'a) ->
            ?jmp:(Bap.Std.jmp Bap.Std.term -> 'a) -> 'Bap.Std.term -> 'a
        end
      module Program :
        sig
          type t = Bap.Std.program Bap.Std.term
          val create : ?tid:Bap.Std.tid -> unit -> Bap.Std.Program.t
          val lift : Bap.Std.symtab -> Bap.Std.program Bap.Std.term
          val to_graph : Bap.Std.Program.t -> Bap.Std.Graphs.Callgraph.t
          val lookup :
            ('a, 'b) Bap.Std.cls ->
            Bap.Std.Program.t -> Bap.Std.tid -> 'Bap.Std.term option
          val parent :
            ('a, 'b) Bap.Std.cls ->
            Bap.Std.Program.t -> Bap.Std.tid -> 'Bap.Std.term option
          module Builder :
            sig
              type t
              val create :
                ?tid:Bap.Std.tid ->
                ?subs:int -> unit -> Bap.Std.Program.Builder.t
              val add_sub :
                Bap.Std.Program.Builder.t -> Bap.Std.sub Bap.Std.term -> unit
              val result :
                Bap.Std.Program.Builder.t -> Bap.Std.program Bap.Std.term
            end
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Tid.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Sub :
        sig
          type t = Bap.Std.sub Bap.Std.term
          val create :
            ?tid:Bap.Std.tid -> ?name:string -> unit -> Bap.Std.Sub.t
          val lift : Bap.Std.block -> Bap.Std.cfg -> Bap.Std.sub Bap.Std.term
          val name : Bap.Std.Sub.t -> string
          val with_name : Bap.Std.Sub.t -> string -> Bap.Std.Sub.t
          val ssa : Bap.Std.Sub.t -> Bap.Std.Sub.t
          val is_ssa : Bap.Std.Sub.t -> bool
          val free_vars : Bap.Std.Sub.t -> Bap.Std.Var.Set.t
          val to_graph : Bap.Std.Sub.t -> Bap.Std.Graphs.Tid.t
          val to_cfg : Bap.Std.Sub.t -> Bap.Std.Graphs.Ir.t
          val of_cfg : Bap.Std.Graphs.Ir.t -> Bap.Std.Sub.t
          val aliases : string list Bap.Std.tag
          val const : unit Bap.Std.tag
          val pure : unit Bap.Std.tag
          val stub : unit Bap.Std.tag
          val extern : unit Bap.Std.tag
          val leaf : unit Bap.Std.tag
          val malloc : unit Bap.Std.tag
          val noreturn : unit Bap.Std.tag
          val returns_twice : unit Bap.Std.tag
          val nothrow : unit Bap.Std.tag
          val entry_point : unit Bap.Std.tag
          module Builder :
            sig
              type t
              val create :
                ?tid:Bap.Std.tid ->
                ?args:int ->
                ?blks:int -> ?name:string -> unit -> Bap.Std.Sub.Builder.t
              val add_blk :
                Bap.Std.Sub.Builder.t -> Bap.Std.blk Bap.Std.term -> unit
              val add_arg :
                Bap.Std.Sub.Builder.t -> Bap.Std.arg Bap.Std.term -> unit
              val result : Bap.Std.Sub.Builder.t -> Bap.Std.sub Bap.Std.term
            end
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Program.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Blk :
        sig
          type t = Bap.Std.blk Bap.Std.term
          type elt =
              [ `Def of Bap.Std.def Bap.Std.term
              | `Jmp of Bap.Std.jmp Bap.Std.term
              | `Phi of Bap.Std.phi Bap.Std.term ]
          val create : ?tid:Bap.Std.tid -> unit -> Bap.Std.Blk.t
          val lift :
            Bap.Std.cfg -> Bap.Std.block -> Bap.Std.blk Bap.Std.term list
          val from_insn : Bap.Std.insn -> Bap.Std.blk Bap.Std.term list
          val split_while :
            Bap.Std.Blk.t ->
            f:(Bap.Std.def Bap.Std.term -> bool) ->
            Bap.Std.Blk.t * Bap.Std.Blk.t
          val split_after :
            Bap.Std.Blk.t ->
            Bap.Std.def Bap.Std.term -> Bap.Std.Blk.t * Bap.Std.Blk.t
          val split_before :
            Bap.Std.Blk.t ->
            Bap.Std.def Bap.Std.term -> Bap.Std.Blk.t * Bap.Std.Blk.t
          val split_top : Bap.Std.Blk.t -> Bap.Std.Blk.t * Bap.Std.Blk.t
          val split_bot : Bap.Std.Blk.t -> Bap.Std.Blk.t * Bap.Std.Blk.t
          val elts :
            ?rev:bool -> Bap.Std.Blk.t -> Bap.Std.Blk.elt Bap.Std.seq
          val map_exp :
            ?skip:[ `def | `jmp | `phi ] list ->
            Bap.Std.Blk.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Blk.t
          val map_elts :
            ?phi:(Bap.Std.phi Bap.Std.term -> Bap.Std.phi Bap.Std.term) ->
            ?def:(Bap.Std.def Bap.Std.term -> Bap.Std.def Bap.Std.term) ->
            ?jmp:(Bap.Std.jmp Bap.Std.term -> Bap.Std.jmp Bap.Std.term) ->
            Bap.Std.blk Bap.Std.term -> Bap.Std.blk Bap.Std.term
          val substitute :
            ?skip:[ `def | `jmp | `phi ] list ->
            Bap.Std.Blk.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Blk.t
          val map_lhs :
            ?skip:[ `def | `phi ] list ->
            Bap.Std.Blk.t -> f:(Bap.Std.var -> Bap.Std.var) -> Bap.Std.Blk.t
          val find_var :
            Bap.Std.Blk.t ->
            Bap.Std.var ->
            [ `Def of Bap.Std.def Bap.Std.term
            | `Phi of Bap.Std.phi Bap.Std.term ] option
          val defines_var : Bap.Std.Blk.t -> Bap.Std.var -> bool
          val free_vars : Bap.Std.Blk.t -> Bap.Std.Var.Set.t
          val uses_var : Bap.Std.Blk.t -> Bap.Std.var -> bool
          val occurs :
            Bap.Std.Blk.t -> after:Bap.Std.tid -> Bap.Std.tid -> bool
          module Builder :
            sig
              type t
              val create :
                ?tid:Bap.Std.tid ->
                ?phis:int ->
                ?defs:int -> ?jmps:int -> unit -> Bap.Std.Blk.Builder.t
              val init :
                ?same_tid:bool ->
                ?copy_phis:bool ->
                ?copy_defs:bool ->
                ?copy_jmps:bool ->
                Bap.Std.blk Bap.Std.term -> Bap.Std.Blk.Builder.t
              val add_def :
                Bap.Std.Blk.Builder.t -> Bap.Std.def Bap.Std.term -> unit
              val add_jmp :
                Bap.Std.Blk.Builder.t -> Bap.Std.jmp Bap.Std.term -> unit
              val add_phi :
                Bap.Std.Blk.Builder.t -> Bap.Std.phi Bap.Std.term -> unit
              val add_elt : Bap.Std.Blk.Builder.t -> Bap.Std.Blk.elt -> unit
              val result : Bap.Std.Blk.Builder.t -> Bap.Std.blk Bap.Std.term
            end
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Sub.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Def :
        sig
          type t = Bap.Std.def Bap.Std.term
          val create :
            ?tid:Bap.Std.tid -> Bap.Std.var -> Bap.Std.exp -> Bap.Std.Def.t
          val lhs : Bap.Std.Def.t -> Bap.Std.var
          val rhs : Bap.Std.Def.t -> Bap.Std.exp
          val with_lhs : Bap.Std.Def.t -> Bap.Std.var -> Bap.Std.Def.t
          val with_rhs : Bap.Std.Def.t -> Bap.Std.exp -> Bap.Std.Def.t
          val map_exp :
            Bap.Std.Def.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Def.t
          val substitute :
            Bap.Std.Def.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Def.t
          val free_vars : Bap.Std.Def.t -> Bap.Std.Var.Set.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Blk.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Jmp :
        sig
          type t = Bap.Std.jmp Bap.Std.term
          val create :
            ?tid:Bap.Std.tid ->
            ?cond:Bap.Std.exp -> Bap.Std.jmp_kind -> Bap.Std.Jmp.t
          val create_call :
            ?tid:Bap.Std.tid ->
            ?cond:Bap.Std.exp -> Bap.Std.call -> Bap.Std.Jmp.t
          val create_goto :
            ?tid:Bap.Std.tid ->
            ?cond:Bap.Std.exp -> Bap.Std.label -> Bap.Std.Jmp.t
          val create_ret :
            ?tid:Bap.Std.tid ->
            ?cond:Bap.Std.exp -> Bap.Std.label -> Bap.Std.Jmp.t
          val create_int :
            ?tid:Bap.Std.tid ->
            ?cond:Bap.Std.exp -> int -> Bap.Std.tid -> Bap.Std.Jmp.t
          val kind : Bap.Std.Jmp.t -> Bap.Std.jmp_kind
          val cond : Bap.Std.Jmp.t -> Bap.Std.exp
          val exps : Bap.Std.Jmp.t -> Bap.Std.exp Bap.Std.seq
          val free_vars : Bap.Std.Jmp.t -> Bap.Std.Var.Set.t
          val map_exp :
            Bap.Std.Jmp.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Jmp.t
          val substitute :
            Bap.Std.Jmp.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Jmp.t
          val with_cond : Bap.Std.Jmp.t -> Bap.Std.exp -> Bap.Std.Jmp.t
          val with_kind : Bap.Std.Jmp.t -> Bap.Std.jmp_kind -> Bap.Std.Jmp.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Def.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Phi :
        sig
          type t = Bap.Std.phi Bap.Std.term
          val create :
            ?tid:Bap.Std.tid ->
            Bap.Std.var -> Bap.Std.tid -> Bap.Std.exp -> Bap.Std.Phi.t
          val of_list :
            ?tid:Bap.Std.tid ->
            Bap.Std.var -> (Bap.Std.tid * Bap.Std.exp) list -> Bap.Std.Phi.t
          val values :
            Bap.Std.Phi.t -> (Bap.Std.tid * Bap.Std.exp) Bap.Std.seq
          val free_vars : Bap.Std.Phi.t -> Bap.Std.Var.Set.t
          val lhs : Bap.Std.Phi.t -> Bap.Std.var
          val with_lhs : Bap.Std.Phi.t -> Bap.Std.var -> Bap.Std.Phi.t
          val map_exp :
            Bap.Std.Phi.t -> f:(Bap.Std.exp -> Bap.Std.exp) -> Bap.Std.Phi.t
          val substitute :
            Bap.Std.Phi.t -> Bap.Std.exp -> Bap.Std.exp -> Bap.Std.Phi.t
          val update :
            Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp -> Bap.Std.Phi.t
          val select : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp option
          val select_or_unknown : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.exp
          val remove : Bap.Std.Phi.t -> Bap.Std.tid -> Bap.Std.Phi.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Jmp.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Arg :
        sig
          type t = Bap.Std.arg Bap.Std.term
          val create :
            ?tid:Bap.Std.tid ->
            ?intent:Bap.Std.intent ->
            Bap.Std.var -> Bap.Std.exp -> Bap.Std.Arg.t
          val lhs : Bap.Std.Arg.t -> Bap.Std.var
          val rhs : Bap.Std.Arg.t -> Bap.Std.exp
          val intent : Bap.Std.Arg.t -> Bap.Std.intent option
          val with_intent : Bap.Std.Arg.t -> Bap.Std.intent -> Bap.Std.Arg.t
          val with_unknown_intent : Bap.Std.Arg.t -> Bap.Std.Arg.t
          val warn_unused : unit Bap.Std.tag
          val alloc_size : unit Bap.Std.tag
          val format : string Bap.Std.tag
          val nonnull : unit Bap.Std.tag
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Phi.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Call :
        sig
          type t = Bap.Std.call
          val create :
            ?return:Bap.Std.label ->
            target:Bap.Std.label -> unit -> Bap.Std.Call.t
          val target : Bap.Std.Call.t -> Bap.Std.label
          val return : Bap.Std.Call.t -> Bap.Std.label option
          val with_target : Bap.Std.Call.t -> Bap.Std.label -> Bap.Std.Call.t
          val with_return : Bap.Std.Call.t -> Bap.Std.label -> Bap.Std.Call.t
          val with_noreturn : Bap.Std.Call.t -> Bap.Std.Call.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.call
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Arg.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Label :
        sig
          type t = Bap.Std.label
          val create : unit -> Bap.Std.Label.t
          val direct : Bap.Std.tid -> Bap.Std.Label.t
          val indirect : Bap.Std.exp -> Bap.Std.Label.t
          val change :
            ?direct:(Bap.Std.tid -> Bap.Std.tid) ->
            ?indirect:(Bap.Std.exp -> Bap.Std.exp) ->
            Bap.Std.Label.t -> Bap.Std.Label.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Bap.Std.label
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Call.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> Trie.String.Suffix.key) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
        end
      module Source :
        sig
          type 'a t = 'Core_kernel.Std.Or_error.t Bap_future.Std.stream
          type 'a source = 'Bap.Std.Source.t
          module Factory :
            sig
              module type S =
                sig
                  type t
                  val list : unit -> string list
                  val find :
                    string ->
                    Bap.Std.Source.Factory.S.t Bap.Std.Source.source option
                  val register :
                    string ->
                    Bap.Std.Source.Factory.S.t Bap.Std.Source.source -> unit
                end
              module Make :
                functor (T : Core_kernel.Std.T->
                  sig
                    type t = T.t
                    val list : unit -> Trie.String.Suffix.key list
                    val find : Trie.String.Suffix.key -> t source option
                    val register : Trie.String.Suffix.key -> t source -> unit
                  end
            end
        end
      module Taint :
        sig
          type t = Bap.Std.tid
          type set = Bap.Std.Tid.Set.t
          val bin_set : set Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_set : set Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_set__ :
            (int -> set) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_set : set Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_set : set Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_set : set Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_set : set Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_set : Core_kernel.Std.Bin_prot.Shape.t
          val compare_set : set -> set -> int
          val set_of_sexp : Sexplib.Sexp.t -> set
          val sexp_of_set : set -> Sexplib.Sexp.t
          type map = Bap.Std.Taint.set Bap.Std.Var.Map.t
          val bin_map : map Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_map : map Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_map__ :
            (int -> map) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_map : map Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_map : map Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_map : map Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_map : map Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_map : Core_kernel.Std.Bin_prot.Shape.t
          val compare_map : map -> map -> int
          val map_of_sexp : Sexplib.Sexp.t -> map
          val sexp_of_map : map -> Sexplib.Sexp.t
          val reg : Bap.Std.Taint.t Bap.Std.tag
          val ptr : Bap.Std.Taint.t Bap.Std.tag
          val regs : Bap.Std.Taint.map Bap.Std.tag
          val ptrs : Bap.Std.Taint.map Bap.Std.tag
          val merge :
            Bap.Std.Taint.map -> Bap.Std.Taint.map -> Bap.Std.Taint.map
          class context :
            object ('a)
              method all_taints : Bap.Std.Taint.set
              method ptr_taints : Bap.Std.addr -> Bap.Std.Taint.set
              method reg_taints : Bap.Std.Bil.result -> Bap.Std.Taint.set
              method taint_ptr :
                Bap.Std.addr -> Bap.Std.size -> Bap.Std.Taint.set -> 'a
              method taint_reg :
                Bap.Std.Bil.result -> Bap.Std.Taint.set -> 'a
            end
          module type S =
            sig
              type ('a, 'e) state
              module Expi :
                sig
                  type ('a, 'e) state = ('a, 'e) state
                  type 'a u = (unit, 'a) state
                  type 'a r = (Bil.result, 'a) state
                  module M : sig type ('a, 'e) t = ('a, 'e) state end
                  module Eval :
                    sig
                      class type ['a, 'r] semantics =
                        ['a, 'r] Eval.T2(M).semantics
                      class type virtual ['a, 'r, 's] domain =
                        ['a, 'r, 's] Eval.T2(M).domain
                      class type virtual ['a, 'r, 's] eff =
                        ['a, 'r, 's] Eval.T2(M).eff
                      class virtual ['a, 'r, 's] t :
                        object
                          method division_by_zero : unit -> ('r, 'a) state
                          method eval_binop :
                            binop -> exp -> exp -> ('r, 'a) M.t
                          method eval_cast :
                            cast -> int -> exp -> ('r, 'a) M.t
                          method eval_concat : exp -> exp -> ('r, 'a) M.t
                          method eval_exp : exp -> ('r, 'a) M.t
                          method eval_extract :
                            int -> int -> exp -> ('r, 'a) M.t
                          method eval_int : word -> ('r, 'a) M.t
                          method eval_ite :
                            cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                          method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                          method eval_load :
                            mem:exp ->
                            addr:exp -> endian -> size -> ('r, 'a) M.t
                          method eval_store :
                            mem:exp ->
                            addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                          method eval_unknown :
                            Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                          method eval_unop : unop -> exp -> ('r, 'a) M.t
                          method eval_var : var -> ('r, 'a) M.t
                          method virtual load : '-> addr -> ('r, 'a) M.t
                          method virtual lookup : var -> ('r, 'a) M.t
                          method private virtual storage_of_value :
                            '-> ('s option, 'a) M.t
                          method virtual store :
                            '-> addr -> word -> ('r, 'a) M.t
                          method type_error : type_error -> ('r, 'a) state
                          method private virtual undefined : ('r, 'a) M.t
                          method virtual update : var -> '-> (unit, 'a) M.t
                          method private virtual value_of_word :
                            word -> ('r, 'a) M.t
                          method private virtual word_of_value :
                            '-> (word option, 'a) M.t
                        end
                    end
                  class ['a] t :
                    object
                      constraint 'a = #Expi.context
                      method division_by_zero : unit -> 'a r
                      method empty : Bil.storage
                      method eval_binop :
                        binop -> exp -> exp -> (Bil.result, 'a) M.t
                      method eval_cast :
                        cast -> int -> exp -> (Bil.result, 'a) M.t
                      method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                      method eval_exp : exp -> (Bil.result, 'a) M.t
                      method eval_extract :
                        int -> int -> exp -> (Bil.result, 'a) M.t
                      method eval_int : word -> (Bil.result, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                      method eval_let :
                        var -> exp -> exp -> (Bil.result, 'a) M.t
                      method eval_load :
                        mem:exp ->
                        addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp ->
                        exp -> endian -> size -> (Bil.result, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                      method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                      method eval_var : var -> (Bil.result, 'a) M.t
                      method load : Bil.storage -> addr -> 'a r
                      method lookup : var -> 'a r
                      method store : Bil.storage -> addr -> word -> 'a r
                      method type_error : type_error -> 'a r
                      method undefined_addr : addr -> 'a r
                      method undefined_var : var -> 'a r
                      method update : var -> Bil.result -> 'a u
                    end
                end
              class ['a] propagator :
                object
                  constraint 'a =
                    < all_taints : set; bindings : (var * Bil.result) seq;
                      create_storage : Bil.storage -> 'a * Bil.result;
                      create_undefined : 'a * Bil.result;
                      create_word : word -> 'a * Bil.result;
                      lookup : var -> Bil.result option;
                      ptr_taints : addr -> set;
                      reg_taints : Bil.result -> set;
                      taint_ptr : addr -> size -> set -> 'a;
                      taint_reg : Bil.result -> set -> 'a;
                      update : var -> Bil.result -> 'a; .. >
                  method division_by_zero : unit -> 'Expi.r
                  method empty : Bil.storage
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method load : Bil.storage -> addr -> 'Expi.r
                  method lookup : var -> 'Expi.r
                  method store : Bil.storage -> addr -> word -> 'Expi.r
                  method type_error : type_error -> 'Expi.r
                  method undefined_addr : addr -> 'Expi.r
                  method undefined_var : var -> 'Expi.r
                  method update : var -> Bil.result -> 'Expi.u
                end
            end
          module Make :
            functor (M : Monads.Std.Monad.State.S2->
              sig
                type ('a, 'e) state = ('a, 'e) M.t
                module Expi :
                  sig
                    type ('a, 'e) state = ('a, 'e) M.t
                    type 'a u = (unit, 'a) state
                    type 'a r = (Bil.result, 'a) state
                    module M : sig type ('a, 'e) t = ('a, 'e) state end
                    module Eval :
                      sig
                        class type ['a, 'r] semantics =
                          ['a, 'r] Eval.T2(M).semantics
                        class type virtual ['a, 'r, 's] domain =
                          ['a, 'r, 's] Eval.T2(M).domain
                        class type virtual ['a, 'r, 's] eff =
                          ['a, 'r, 's] Eval.T2(M).eff
                        class virtual ['a, 'r, 's] t :
                          object
                            method division_by_zero : unit -> ('r, 'a) state
                            method eval_binop :
                              binop -> exp -> exp -> ('r, 'a) M.t
                            method eval_cast :
                              cast -> int -> exp -> ('r, 'a) M.t
                            method eval_concat : exp -> exp -> ('r, 'a) M.t
                            method eval_exp : exp -> ('r, 'a) M.t
                            method eval_extract :
                              int -> int -> exp -> ('r, 'a) M.t
                            method eval_int : word -> ('r, 'a) M.t
                            method eval_ite :
                              cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                            method eval_let :
                              var -> exp -> exp -> ('r, 'a) M.t
                            method eval_load :
                              mem:exp ->
                              addr:exp -> endian -> size -> ('r, 'a) M.t
                            method eval_store :
                              mem:exp ->
                              addr:exp ->
                              exp -> endian -> size -> ('r, 'a) M.t
                            method eval_unknown :
                              Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                            method eval_unop : unop -> exp -> ('r, 'a) M.t
                            method eval_var : var -> ('r, 'a) M.t
                            method virtual load : '-> addr -> ('r, 'a) M.t
                            method virtual lookup : var -> ('r, 'a) M.t
                            method private virtual storage_of_value :
                              '-> ('s option, 'a) M.t
                            method virtual store :
                              '-> addr -> word -> ('r, 'a) M.t
                            method type_error : type_error -> ('r, 'a) state
                            method private virtual undefined : ('r, 'a) M.t
                            method virtual update :
                              var -> '-> (unit, 'a) M.t
                            method private virtual value_of_word :
                              word -> ('r, 'a) M.t
                            method private virtual word_of_value :
                              '-> (word option, 'a) M.t
                          end
                      end
                    class ['a] t :
                      object
                        constraint 'a = #Expi.context
                        method division_by_zero : unit -> 'a r
                        method empty : Bil.storage
                        method eval_binop :
                          binop -> exp -> exp -> (Bil.result, 'a) M.t
                        method eval_cast :
                          cast -> int -> exp -> (Bil.result, 'a) M.t
                        method eval_concat :
                          exp -> exp -> (Bil.result, 'a) M.t
                        method eval_exp : exp -> (Bil.result, 'a) M.t
                        method eval_extract :
                          int -> int -> exp -> (Bil.result, 'a) M.t
                        method eval_int : word -> (Bil.result, 'a) M.t
                        method eval_ite :
                          cond:exp ->
                          yes:exp -> no:exp -> (Bil.result, 'a) M.t
                        method eval_let :
                          var -> exp -> exp -> (Bil.result, 'a) M.t
                        method eval_load :
                          mem:exp ->
                          addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                        method eval_store :
                          mem:exp ->
                          addr:exp ->
                          exp -> endian -> size -> (Bil.result, 'a) M.t
                        method eval_unknown :
                          Trie.String.Suffix.key ->
                          typ -> (Bil.result, 'a) M.t
                        method eval_unop :
                          unop -> exp -> (Bil.result, 'a) M.t
                        method eval_var : var -> (Bil.result, 'a) M.t
                        method load : Bil.storage -> addr -> 'a r
                        method lookup : var -> 'a r
                        method store : Bil.storage -> addr -> word -> 'a r
                        method type_error : type_error -> 'a r
                        method undefined_addr : addr -> 'a r
                        method undefined_var : var -> 'a r
                        method update : var -> Bil.result -> 'a u
                      end
                  end
                class ['a] propagator :
                  object
                    constraint 'a =
                      < all_taints : set; bindings : (var * Bil.result) seq;
                        create_storage : Bil.storage -> 'a * Bil.result;
                        create_undefined : 'a * Bil.result;
                        create_word : word -> 'a * Bil.result;
                        lookup : var -> Bil.result option;
                        ptr_taints : addr -> set;
                        reg_taints : Bil.result -> set;
                        taint_ptr : addr -> size -> set -> 'a;
                        taint_reg : Bil.result -> set -> 'a;
                        update : var -> Bil.result -> 'a; .. >
                    method division_by_zero : unit -> 'Expi.r
                    method empty : Bil.storage
                    method eval_binop :
                      binop -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_cast :
                      cast -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                    method eval_exp : exp -> (Bil.result, 'a) M.t
                    method eval_extract :
                      int -> int -> exp -> (Bil.result, 'a) M.t
                    method eval_int : word -> (Bil.result, 'a) M.t
                    method eval_ite :
                      cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                    method eval_let :
                      var -> exp -> exp -> (Bil.result, 'a) M.t
                    method eval_load :
                      mem:exp ->
                      addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_store :
                      mem:exp ->
                      addr:exp ->
                      exp -> endian -> size -> (Bil.result, 'a) M.t
                    method eval_unknown :
                      Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                    method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                    method eval_var : var -> (Bil.result, 'a) M.t
                    method load : Bil.storage -> addr -> 'Expi.r
                    method lookup : var -> 'Expi.r
                    method store : Bil.storage -> addr -> word -> 'Expi.r
                    method type_error : type_error -> 'Expi.r
                    method undefined_addr : addr -> 'Expi.r
                    method undefined_var : var -> 'Expi.r
                    method update : var -> Bil.result -> 'Expi.u
                  end
              end
          type ('a, 'e) state = ('a, 'e) Biri.state
          module Expi :
            sig
              type ('a, 'e) state = ('a, 'e) Biri.state
              type 'a u = (unit, 'a) state
              type 'a r = (Bil.result, 'a) state
              module M : sig type ('a, 'e) t = ('a, 'e) state end
              module Eval :
                sig
                  class type ['a, 'r] semantics =
                    ['a, 'r] Eval.T2(M).semantics
                  class type virtual ['a, 'r, 's] domain =
                    ['a, 'r, 's] Eval.T2(M).domain
                  class type virtual ['a, 'r, 's] eff =
                    ['a, 'r, 's] Eval.T2(M).eff
                  class virtual ['a, 'r, 's] t :
                    object
                      method division_by_zero : unit -> ('r, 'a) state
                      method eval_binop : binop -> exp -> exp -> ('r, 'a) M.t
                      method eval_cast : cast -> int -> exp -> ('r, 'a) M.t
                      method eval_concat : exp -> exp -> ('r, 'a) M.t
                      method eval_exp : exp -> ('r, 'a) M.t
                      method eval_extract : int -> int -> exp -> ('r, 'a) M.t
                      method eval_int : word -> ('r, 'a) M.t
                      method eval_ite :
                        cond:exp -> yes:exp -> no:exp -> ('r, 'a) M.t
                      method eval_let : var -> exp -> exp -> ('r, 'a) M.t
                      method eval_load :
                        mem:exp -> addr:exp -> endian -> size -> ('r, 'a) M.t
                      method eval_store :
                        mem:exp ->
                        addr:exp -> exp -> endian -> size -> ('r, 'a) M.t
                      method eval_unknown :
                        Trie.String.Suffix.key -> typ -> ('r, 'a) M.t
                      method eval_unop : unop -> exp -> ('r, 'a) M.t
                      method eval_var : var -> ('r, 'a) M.t
                      method virtual load : '-> addr -> ('r, 'a) M.t
                      method virtual lookup : var -> ('r, 'a) M.t
                      method private virtual storage_of_value :
                        '-> ('s option, 'a) M.t
                      method virtual store :
                        '-> addr -> word -> ('r, 'a) M.t
                      method type_error : type_error -> ('r, 'a) state
                      method private virtual undefined : ('r, 'a) M.t
                      method virtual update : var -> '-> (unit, 'a) M.t
                      method private virtual value_of_word :
                        word -> ('r, 'a) M.t
                      method private virtual word_of_value :
                        '-> (word option, 'a) M.t
                    end
                end
              class ['a] t :
                object
                  constraint 'a = #Expi.context
                  method division_by_zero : unit -> 'a r
                  method empty : Bil.storage
                  method eval_binop :
                    binop -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_cast :
                    cast -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
                  method eval_exp : exp -> (Bil.result, 'a) M.t
                  method eval_extract :
                    int -> int -> exp -> (Bil.result, 'a) M.t
                  method eval_int : word -> (Bil.result, 'a) M.t
                  method eval_ite :
                    cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
                  method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
                  method eval_load :
                    mem:exp ->
                    addr:exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_store :
                    mem:exp ->
                    addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
                  method eval_unknown :
                    Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
                  method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
                  method eval_var : var -> (Bil.result, 'a) M.t
                  method load : Bil.storage -> addr -> 'a r
                  method lookup : var -> 'a r
                  method store : Bil.storage -> addr -> word -> 'a r
                  method type_error : type_error -> 'a r
                  method undefined_addr : addr -> 'a r
                  method undefined_var : var -> 'a r
                  method update : var -> Bil.result -> 'a u
                end
            end
          class ['a] propagator :
            object
              constraint 'a =
                < all_taints : set; bindings : (var * Bil.result) seq;
                  create_storage : Bil.storage -> 'a * Bil.result;
                  create_undefined : 'a * Bil.result;
                  create_word : word -> 'a * Bil.result;
                  lookup : var -> Bil.result option;
                  ptr_taints : addr -> set; reg_taints : Bil.result -> set;
                  taint_ptr : addr -> size -> set -> 'a;
                  taint_reg : Bil.result -> set -> 'a;
                  update : var -> Bil.result -> 'a; .. >
              method division_by_zero : unit -> 'Expi.r
              method empty : Bil.storage
              method eval_binop : binop -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_cast : cast -> int -> exp -> (Bil.result, 'a) M.t
              method eval_concat : exp -> exp -> (Bil.result, 'a) M.t
              method eval_exp : exp -> (Bil.result, 'a) M.t
              method eval_extract : int -> int -> exp -> (Bil.result, 'a) M.t
              method eval_int : word -> (Bil.result, 'a) M.t
              method eval_ite :
                cond:exp -> yes:exp -> no:exp -> (Bil.result, 'a) M.t
              method eval_let : var -> exp -> exp -> (Bil.result, 'a) M.t
              method eval_load :
                mem:exp -> addr:exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_store :
                mem:exp ->
                addr:exp -> exp -> endian -> size -> (Bil.result, 'a) M.t
              method eval_unknown :
                Trie.String.Suffix.key -> typ -> (Bil.result, 'a) M.t
              method eval_unop : unop -> exp -> (Bil.result, 'a) M.t
              method eval_var : var -> (Bil.result, 'a) M.t
              method load : Bil.storage -> addr -> 'Expi.r
              method lookup : var -> 'Expi.r
              method store : Bil.storage -> addr -> word -> 'Expi.r
              method type_error : type_error -> 'Expi.r
              method undefined_addr : addr -> 'Expi.r
              method undefined_var : var -> 'Expi.r
              method update : var -> Bil.result -> 'Expi.u
            end
          val pp_set : Bap.Std.Taint.set Regular.Std.printer
          val pp_map : Bap.Std.Taint.map Regular.Std.printer
          module Map :
            sig
              type t = map
              val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
              val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
              val __bin_read_t__ :
                (int -> t) Core_kernel.Std.Bin_prot.Read.reader
              val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
              val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
              val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
              val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
              val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
              val t_of_sexp : Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Sexplib.Sexp.t
              val to_string : t -> Trie.String.Suffix.key
              val str : unit -> t -> Trie.String.Suffix.key
              val pps : unit -> t -> Trie.String.Suffix.key
              val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
              val pp_seq : Format.formatter -> t Seq.t -> unit
              val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              val comparator :
                (t, comparator_witness) Core_kernel__.Comparator.comparator
              module Map :
                sig
                  module Key :
                    sig
                      type t = map
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (map, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : map -> '-> 'a t
                      val of_alist :
                        (map * 'a) list ->
                        [ `Duplicate_key of map | `Ok of 'a t ]
                      val of_alist_or_error :
                        (map * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (map * 'a) list -> 'a t
                      val of_alist_multi : (map * 'a) list -> 'a list t
                      val of_alist_fold :
                        (map * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (map * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (map * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (map * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> map * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:map -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of map | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (map, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        map Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:map -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:map -> data:'-> 'a list t
                      val remove_multi : 'a list t -> map -> 'a list t
                      val change :
                        'a t -> map -> f:('a option -> 'a option) -> 'a t
                      val update : 'a t -> map -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> map -> 'a option
                      val find_exn : 'a t -> map -> 'a
                      val remove : 'a t -> map -> 'a t
                      val mem : 'a t -> map -> bool
                      val iter_keys : 'a t -> f:(map -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:map -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:map ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi : 'a t -> f:(key:map -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:map ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(map -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:map -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:map -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:map -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t -> f:(key:map -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> map list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (map * 'a) list
                      val validate :
                        name:(map -> Trie.String.Suffix.key) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:map ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (map, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (map * 'a) option
                      val min_elt_exn : 'a t -> map * 'a
                      val max_elt : 'a t -> (map * 'a) option
                      val max_elt_exn : 'a t -> map * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:map -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:map -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:map -> data:'-> bool) -> int
                      val split :
                        'a t -> map -> 'a t * (map * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:map Base__.Maybe_bound.t ->
                        upper_bound:map Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:map ->
                        max:map ->
                        init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:map -> max:map -> (map * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> map -> (map * 'a) option
                      val nth : 'a t -> int -> (map * 'a) option
                      val nth_exn : 'a t -> int -> map * 'a
                      val rank : 'a t -> map -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:map ->
                        ?keys_less_or_equal_to:map ->
                        'a t -> (map * 'a) Base__.Sequence.t
                      val obs :
                        map Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        map Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig val t_of_sexp : Sexplib.Sexp.t -> map end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (map, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : map -> '-> 'a t
                  val of_alist :
                    (map * 'a) list ->
                    [ `Duplicate_key of map | `Ok of 'a t ]
                  val of_alist_or_error :
                    (map * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (map * 'a) list -> 'a t
                  val of_alist_multi : (map * 'a) list -> 'a list t
                  val of_alist_fold :
                    (map * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (map * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (map * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (map * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> map * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:map -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of map | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (map, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    map Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:map -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:map -> data:'-> 'a list t
                  val remove_multi : 'a list t -> map -> 'a list t
                  val change :
                    'a t -> map -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> map -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> map -> 'a option
                  val find_exn : 'a t -> map -> 'a
                  val remove : 'a t -> map -> 'a t
                  val mem : 'a t -> map -> bool
                  val iter_keys : 'a t -> f:(map -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:map -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:map ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:map -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:map ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(map -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:map -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:map -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:map -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:map -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> map list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (map * 'a) list
                  val validate :
                    name:(map -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:map ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (map, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (map * 'a) option
                  val min_elt_exn : 'a t -> map * 'a
                  val max_elt : 'a t -> (map * 'a) option
                  val max_elt_exn : 'a t -> map * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:map -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:map -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:map -> data:'-> bool) -> int
                  val split : 'a t -> map -> 'a t * (map * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:map Base__.Maybe_bound.t ->
                    upper_bound:map Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:map ->
                    max:map ->
                    init:'-> f:(key:map -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:map -> max:map -> (map * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> map -> (map * 'a) option
                  val nth : 'a t -> int -> (map * 'a) option
                  val nth_exn : 'a t -> int -> map * 'a
                  val rank : 'a t -> map -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:map ->
                    ?keys_less_or_equal_to:map ->
                    'a t -> (map * 'a) Base__.Sequence.t
                  val obs :
                    map Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    map Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> map end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : map Bin_prot.Type_class.t
                               val bin_read_t : map Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> map)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 map Bin_prot.Type_class.reader
                               val bin_size_t : map Bin_prot.Size.sizer
                               val bin_write_t : map Bin_prot.Write.writer
                               val bin_writer_t :
                                 map Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 map -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = map
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      val bin_t : t Bin_prot.Type_class.t
                      val bin_read_t : t Bin_prot.Read.reader
                      val __bin_read_t__ :
                        (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                      val bin_reader_t : t Bin_prot.Type_class.reader
                      val bin_size_t : t Bin_prot.Size.sizer
                      val bin_write_t : t Bin_prot.Write.writer
                      val bin_writer_t : t Bin_prot.Type_class.writer
                      val bin_shape_t : Bin_prot.Shape.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (map, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(map -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> map -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> map -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(map -> bool) -> bool
                      val for_all : t -> f:(map -> bool) -> bool
                      val count : t -> f:(map -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(map -> 'sum) -> 'sum
                      val find : t -> f:(map -> bool) -> map option
                      val find_map : t -> f:(map -> 'a option) -> 'a option
                      val to_list : t -> map list
                      val to_array : t -> map array
                      val invariants : t -> bool
                      val mem : t -> map -> bool
                      val add : t -> map -> t
                      val remove : t -> map -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (map, map) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           map ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(map -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of map * map
                           | `Left of map
                           | `Right of map ] -> unit) ->
                        unit
                      val filter : t -> f:(map -> bool) -> t
                      val partition_tf : t -> f:(map -> bool) -> t * t
                      val elements : t -> map list
                      val min_elt : t -> map option
                      val min_elt_exn : t -> map
                      val max_elt : t -> map option
                      val max_elt_exn : t -> map
                      val choose : t -> map option
                      val choose_exn : t -> map
                      val split : t -> map -> t * map option * t
                      val group_by :
                        t -> equiv:(map -> map -> bool) -> t list
                      val find_exn : t -> f:(map -> bool) -> map
                      val find_index : t -> int -> map option
                      val nth : t -> int -> map option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:map ->
                        ?less_or_equal_to:map -> t -> map Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:map ->
                        ?less_or_equal_to:map ->
                        t ->
                        t ->
                        (map, map)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(map -> 'data) ->
                        (map, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        map Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        map Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : map -> t
                      val union_list : t list -> t
                      val of_list : map list -> t
                      val of_array : map array -> t
                      val of_sorted_array : map array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : map array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> map) -> t
                      val stable_dedup_list : map list -> map list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> map) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> map option) -> t
                      val of_tree : t -> t
                      val of_hash_set : map Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (map, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (map, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        map Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> map
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (map, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(map -> unit) -> unit
                  val fold :
                    t -> init:'accum -> f:('accum -> map -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> map -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(map -> bool) -> bool
                  val for_all : t -> f:(map -> bool) -> bool
                  val count : t -> f:(map -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(map -> 'sum) -> 'sum
                  val find : t -> f:(map -> bool) -> map option
                  val find_map : t -> f:(map -> 'a option) -> 'a option
                  val to_list : t -> map list
                  val to_array : t -> map array
                  val invariants : t -> bool
                  val mem : t -> map -> bool
                  val add : t -> map -> t
                  val remove : t -> map -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (map, map) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       map ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(map -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of map * map | `Left of map | `Right of map ] ->
                       unit) ->
                    unit
                  val filter : t -> f:(map -> bool) -> t
                  val partition_tf : t -> f:(map -> bool) -> t * t
                  val elements : t -> map list
                  val min_elt : t -> map option
                  val min_elt_exn : t -> map
                  val max_elt : t -> map option
                  val max_elt_exn : t -> map
                  val choose : t -> map option
                  val choose_exn : t -> map
                  val split : t -> map -> t * map option * t
                  val group_by : t -> equiv:(map -> map -> bool) -> t list
                  val find_exn : t -> f:(map -> bool) -> map
                  val find_index : t -> int -> map option
                  val nth : t -> int -> map option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:map ->
                    ?less_or_equal_to:map -> t -> map Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:map ->
                    ?less_or_equal_to:map ->
                    t ->
                    t ->
                    (map, map)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(map -> 'data) ->
                    (map, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    map Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    map Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : map -> t
                  val union_list : t list -> t
                  val of_list : map list -> t
                  val of_array : map array -> t
                  val of_sorted_array : map array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : map array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> map) -> t
                  val stable_dedup_list : map list -> map list
                  val map : ('a, 'b) Base.Set.t -> f:('-> map) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> map option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : map Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (map, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (map, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    map Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> map end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : map Bin_prot.Type_class.t
                               val bin_read_t : map Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> map)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 map Bin_prot.Type_class.reader
                               val bin_size_t : map Bin_prot.Size.sizer
                               val bin_write_t : map Bin_prot.Write.writer
                               val bin_writer_t :
                                 map Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 map -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              val hash : t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Label.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> Trie.String.Suffix.key) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                  val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                  val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                  val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                  val __bin_read_t__ :
                    ('a, int -> 'a t) Bin_prot.Read.reader1
                  val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
                  val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
                  val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                  val bin_shape_t : Bin_prot.Shape.t
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_t : t Bin_prot.Type_class.t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = map
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> map -> Core_kernel__.Import.bool
                  val lookup : 'a t -> map -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> map -> 'a
                  val enqueue :
                    'a t -> map -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> map -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> map -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> map -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (map * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> map Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (map * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> map * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> map -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> map -> Core_kernel__.Import.unit
                  val replace : 'a t -> map -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> map -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:map -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:map -> data:'-> 'b) -> 'b
                end
              type info =
                  Trie.String.Suffix.key *
                  [ `Ver of Trie.String.Suffix.key ] *
                  Trie.String.Suffix.key option
              val version : Trie.String.Suffix.key
              val size_in_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> int
              val of_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
              val to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
              val blit_to_bytes :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Regular.Std.bytes -> t -> int -> unit
              val of_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
              val to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
              val blit_to_bigstring :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.bigstring -> t -> int -> unit
              module Io :
                sig
                  val read :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t
                  val load :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.In_channel.t -> t
                  val load_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
                  val scan :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.In_channel.t -> unit -> t option
                  val write :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Trie.String.Suffix.key -> t -> unit
                  val save :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t -> t -> unit
                  val save_all :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t -> t list -> unit
                  val dump :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Core_kernel.Std.Out_channel.t ->
                    (unit -> t option) -> unit
                  val show :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key -> t -> unit
                  val print :
                    ?ver:Trie.String.Suffix.key ->
                    ?fmt:Trie.String.Suffix.key ->
                    Format.formatter -> t -> unit
                end
              module Cache :
                sig
                  val load : Regular.Std.digest -> t option
                  val save : Regular.Std.digest -> t -> unit
                end
              val add_reader :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader -> unit
              val add_writer :
                ?desc:Trie.String.Suffix.key ->
                ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer -> unit
              val available_readers : unit -> info list
              val default_reader : unit -> info
              val set_default_reader :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val available_writers : unit -> info list
              val default_writer : unit -> info
              val set_default_writer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val default_printer : unit -> info option
              val set_default_printer :
                ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
              val with_printer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> (unit -> 'a) -> 'a
              val find_reader :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.reader option
              val find_writer :
                ?ver:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t Regular.Std.writer option
            end
        end
      type 'a source = 'Bap.Std.Source.t
      module Symbolizer :
        sig
          type t = Bap.Std.symbolizer
          val create :
            (Bap.Std.addr -> string option) -> Bap.Std.Symbolizer.t
          val of_blocks :
            (string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
            Bap.Std.Symbolizer.t
          val resolve : Bap.Std.Symbolizer.t -> Bap.Std.addr -> string
          val chain : Bap.Std.Symbolizer.t list -> Bap.Std.Symbolizer.t
          val empty : Bap.Std.Symbolizer.t
          module Factory :
            sig
              type t = Bap.Std.symbolizer
              val list : unit -> Trie.String.Suffix.key list
              val find : Trie.String.Suffix.key -> t Source.source option
              val register :
                Trie.String.Suffix.key -> t Source.source -> unit
            end
        end
      module Rooter :
        sig
          type t = Bap.Std.rooter
          val create : Bap.Std.addr Bap.Std.seq -> Bap.Std.Rooter.t
          val of_image : Bap.Std.image -> Bap.Std.Rooter.t
          val of_blocks :
            (string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
            Bap.Std.Rooter.t
          val roots : Bap.Std.Rooter.t -> Bap.Std.addr Bap.Std.seq
          val union :
            Bap.Std.Rooter.t -> Bap.Std.Rooter.t -> Bap.Std.Rooter.t
          module Factory :
            sig
              type t = Bap.Std.rooter
              val list : unit -> Trie.String.Suffix.key list
              val find : Trie.String.Suffix.key -> t Source.source option
              val register :
                Trie.String.Suffix.key -> t Source.source -> unit
            end
        end
      module Brancher :
        sig
          type t = Bap.Std.brancher
          type dest = Bap.Std.addr option * Bap.Std.edge
          val dest_of_sexp : Sexplib.Sexp.t -> dest
          val sexp_of_dest : dest -> Sexplib.Sexp.t
          type dests = Bap.Std.Brancher.dest list
          val dests_of_sexp : Sexplib.Sexp.t -> dests
          val sexp_of_dests : dests -> Sexplib.Sexp.t
          val create :
            (Bap.Std.mem ->
             Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Brancher.dests) ->
            Bap.Std.Brancher.t
          val of_bil : Bap.Std.arch -> Bap.Std.Brancher.t
          val resolve :
            Bap.Std.Brancher.t ->
            Bap.Std.mem ->
            Bap.Std.Disasm_expert.Basic.full_insn -> Bap.Std.Brancher.dests
          module Factory :
            sig
              type t = Bap.Std.brancher
              val list : unit -> Trie.String.Suffix.key list
              val find : Trie.String.Suffix.key -> t Source.source option
              val register :
                Trie.String.Suffix.key -> t Source.source -> unit
            end
        end
      module Reconstructor :
        sig
          type t = Bap.Std.reconstructor
          val create :
            (Bap.Std.cfg -> Bap.Std.symtab) -> Bap.Std.Reconstructor.t
          val default :
            (Bap.Std.word -> string) ->
            Bap.Std.word list -> Bap.Std.Reconstructor.t
          val of_blocks :
            (string * Bap.Std.addr * Bap.Std.addr) Bap.Std.seq ->
            Bap.Std.Reconstructor.t
          val run : Bap.Std.Reconstructor.t -> Bap.Std.cfg -> Bap.Std.symtab
          module Factory :
            sig
              type t = Bap.Std.reconstructor
              val list : unit -> Trie.String.Suffix.key list
              val find : Trie.String.Suffix.key -> t Source.source option
              val register :
                Trie.String.Suffix.key -> t Source.source -> unit
            end
        end
      module Event :
        sig
          type t = ..
          type event = Bap.Std.Event.t = ..
          val stream : Bap.Std.Event.t Bap_future.Std.stream
          val send : Bap.Std.Event.t -> unit
          val register_printer : (Bap.Std.Event.t -> string option) -> unit
          module Log :
            sig
              type level = Debug | Info | Warning | Error
              type info = {
                level : Bap.Std.Event.Log.level;
                section : string;
                message : string;
              }
              type event += Message of Bap.Std.Event.Log.info
              val message :
                Bap.Std.Event.Log.level ->
                section:string ->
                ('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
              type event +=
                  Progress of { task : string; note : string option;
                    stage : int option; total : int option;
                  }
              val progress :
                ?note:string -> ?stage:int -> ?total:int -> string -> unit
            end
          val to_string : t -> Trie.String.Suffix.key
          val str : unit -> t -> Trie.String.Suffix.key
          val pps : unit -> t -> Trie.String.Suffix.key
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq : Format.formatter -> t Seq.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
        end
      type event = Bap.Std.Event.t = ..
      type project
      module Project :
        sig
          type t = Bap.Std.project
          type input
          type info =
              Trie.String.Suffix.key * [ `Ver of Trie.String.Suffix.key ] *
              Trie.String.Suffix.key option
          val version : Trie.String.Suffix.key
          val size_in_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> int
          val of_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Regular.Std.bytes -> t
          val to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:Trie.String.Suffix.key ->
            ?fmt:Trie.String.Suffix.key ->
            Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Trie.String.Suffix.key -> t
              val load :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Trie.String.Suffix.key -> t -> unit
              val save :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> t -> unit
              val print :
                ?ver:Trie.String.Suffix.key ->
                ?fmt:Trie.String.Suffix.key -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:Trie.String.Suffix.key ->
            ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer :
            ?ver:Trie.String.Suffix.key -> Trie.String.Suffix.key -> unit
          val with_printer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.reader option
          val find_writer :
            ?ver:Trie.String.Suffix.key ->
            Trie.String.Suffix.key -> t Regular.Std.writer option
          val create :
            ?disassembler:string ->
            ?brancher:Bap.Std.brancher Bap.Std.source ->
            ?symbolizer:Bap.Std.symbolizer Bap.Std.source ->
            ?rooter:Bap.Std.rooter Bap.Std.source ->
            ?reconstructor:Bap.Std.reconstructor Bap.Std.source ->
            Bap.Std.Project.input ->
            Bap.Std.Project.t Core_kernel.Std.Or_error.t
          val arch : Bap.Std.Project.t -> Bap.Std.arch
          val disasm : Bap.Std.Project.t -> Bap.Std.disasm
          val program : Bap.Std.Project.t -> Bap.Std.program Bap.Std.term
          val with_program :
            Bap.Std.Project.t ->
            Bap.Std.program Bap.Std.term -> Bap.Std.Project.t
          val symbols : Bap.Std.Project.t -> Bap.Std.symtab
          val with_symbols :
            Bap.Std.Project.t -> Bap.Std.symtab -> Bap.Std.Project.t
          val storage : Bap.Std.Project.t -> Bap.Std.dict
          val with_storage :
            Bap.Std.Project.t -> Bap.Std.dict -> Bap.Std.Project.t
          val memory : Bap.Std.Project.t -> Bap.Std.value Bap.Std.memmap
          val tag_memory :
            Bap.Std.Project.t ->
            Bap.Std.mem -> 'Bap.Std.tag -> '-> Bap.Std.Project.t
          val substitute :
            Bap.Std.Project.t ->
            Bap.Std.mem -> string Bap.Std.tag -> string -> Bap.Std.Project.t
          val with_memory :
            Bap.Std.Project.t ->
            Bap.Std.value Bap.Std.memmap -> Bap.Std.Project.t
          val set :
            Bap.Std.Project.t -> 'Bap.Std.tag -> '-> Bap.Std.Project.t
          val get : Bap.Std.Project.t -> 'Bap.Std.tag -> 'a option
          val has : Bap.Std.Project.t -> 'Bap.Std.tag -> bool
          val del : Bap.Std.Project.t -> 'Bap.Std.tag -> Bap.Std.Project.t
          module Info :
            sig
              val file : string Bap_future.Std.stream
              val arch : Bap.Std.arch Bap_future.Std.stream
              val data : Bap.Std.value Bap.Std.memmap Bap_future.Std.stream
              val code : Bap.Std.value Bap.Std.memmap Bap_future.Std.stream
              val cfg : Bap.Std.cfg Bap_future.Std.stream
              val symtab : Bap.Std.symtab Bap_future.Std.stream
              val program :
                Bap.Std.program Bap.Std.term Bap_future.Std.stream
              val spec : Ogre.Doc.t Bap_future.Std.stream
            end
          module Input :
            sig
              type t = Bap.Std.Project.input
              val file :
                ?loader:string -> filename:string -> Bap.Std.Project.Input.t
              val binary :
                ?base:Bap.Std.addr ->
                Bap.Std.arch -> filename:string -> Bap.Std.Project.Input.t
              val create :
                ?finish:(Bap.Std.project -> Bap.Std.project) ->
                Bap.Std.arch ->
                string ->
                code:Bap.Std.value Bap.Std.memmap ->
                data:Bap.Std.value Bap.Std.memmap -> Bap.Std.Project.Input.t
              val register_loader :
                string -> (string -> Bap.Std.Project.Input.t) -> unit
              val available_loaders : unit -> string list
            end
          type pass
          val register_pass :
            ?autorun:bool ->
            ?runonce:bool ->
            ?deps:string list ->
            ?name:string -> (Bap.Std.Project.t -> Bap.Std.Project.t) -> unit
          val register_pass' :
            ?autorun:bool ->
            ?runonce:bool ->
            ?deps:string list ->
            ?name:string -> (Bap.Std.Project.t -> unit) -> unit
          val passes : unit -> Bap.Std.Project.pass list
          val find_pass : string -> Bap.Std.Project.pass option
          type second = float
          module Pass :
            sig
              type t = Bap.Std.Project.pass
              type error =
                  Unsat_dep of Bap.Std.Project.pass * string
                | Runtime_error of Bap.Std.Project.pass * exn
              val sexp_of_error : error -> Sexplib.Sexp.t
              exception Failed of Bap.Std.Project.Pass.error
              val run :
                Bap.Std.Project.Pass.t ->
                Bap.Std.project ->
                (Bap.Std.project, Bap.Std.Project.Pass.error)
                Core_kernel.Std.Result.t
              val run_exn :
                Bap.Std.Project.Pass.t -> Bap.Std.project -> Bap.Std.project
              val name : Bap.Std.Project.Pass.t -> string
              val autorun : Bap.Std.Project.Pass.t -> bool
            end
          val restore_state : Bap.Std.Project.t -> unit
        end
      module Self :
        functor () ->
          sig
            val name : string
            val version : string
            val doc : string
            val argv : string array
            val debug :
              ('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
            val info :
              ('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
            val warning :
              ('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
            val error :
              ('a, Format.formatter, unit) Core_kernel.Std.format -> 'a
            val debug_formatter : Format.formatter
            val info_formatter : Format.formatter
            val warning_formatter : Format.formatter
            val error_formatter : Format.formatter
            val report_progress :
              ?task:string ->
              ?note:string -> ?stage:int -> ?total:int -> unit -> unit
            module Config :
              sig
                val version : string
                val datadir : string
                val libdir : string
                val confdir : string
                type 'a param
                type 'parser = string -> [ `Error of string | `Ok of 'a ]
                type 'a converter
                val converter :
                  'Bap.Std.Self.Config.parser ->
                  'Regular.Std.printer ->
                  '-> 'Bap.Std.Self.Config.converter
                val deprecated : string
                val param :
                  'Bap.Std.Self.Config.converter ->
                  ?deprecated:string ->
                  ?default:'->
                  ?as_flag:'->
                  ?docv:string ->
                  ?doc:string ->
                  ?synonyms:string list ->
                  string -> 'Bap.Std.Self.Config.param
                val param_all :
                  'Bap.Std.Self.Config.converter ->
                  ?deprecated:string ->
                  ?default:'a list ->
                  ?as_flag:'->
                  ?docv:string ->
                  ?doc:string ->
                  ?synonyms:string list ->
                  string -> 'a list Bap.Std.Self.Config.param
                val flag :
                  ?deprecated:string ->
                  ?docv:string ->
                  ?doc:string ->
                  ?synonyms:string list ->
                  string -> bool Bap.Std.Self.Config.param
                val determined :
                  'Bap.Std.Self.Config.param -> 'Bap_future.Std.future
                type reader = {
                  get : 'a. 'Bap.Std.Self.Config.param -> 'a;
                }
                val when_ready : (Bap.Std.Self.Config.reader -> unit) -> unit
                type manpage_block =
                    [ `I of string * string
                    | `Noblank
                    | `P of string
                    | `Pre of string
                    | `S of string ]
                val manpage : Bap.Std.Self.Config.manpage_block list -> unit
                val bool : bool Bap.Std.Self.Config.converter
                val char : char Bap.Std.Self.Config.converter
                val int : int Bap.Std.Self.Config.converter
                val nativeint : nativeint Bap.Std.Self.Config.converter
                val int32 : int32 Bap.Std.Self.Config.converter
                val int64 : int64 Bap.Std.Self.Config.converter
                val float : float Bap.Std.Self.Config.converter
                val string : string Bap.Std.Self.Config.converter
                val enum :
                  (string * 'a) list -> 'Bap.Std.Self.Config.converter
                val doc_enum : ?quoted:bool -> (string * 'a) list -> string
                val file : string Bap.Std.Self.Config.converter
                val dir : string Bap.Std.Self.Config.converter
                val non_dir_file : string Bap.Std.Self.Config.converter
                val list :
                  ?sep:char ->
                  'Bap.Std.Self.Config.converter ->
                  'a list Bap.Std.Self.Config.converter
                val array :
                  ?sep:char ->
                  'Bap.Std.Self.Config.converter ->
                  'a array Bap.Std.Self.Config.converter
                val pair :
                  ?sep:char ->
                  'Bap.Std.Self.Config.converter ->
                  'Bap.Std.Self.Config.converter ->
                  ('a * 'b) Bap.Std.Self.Config.converter
                val t2 :
                  ?sep:char ->
                  'Bap.Std.Self.Config.converter ->
                  'Bap.Std.Self.Config.converter ->
                  ('a * 'b) Bap.Std.Self.Config.converter
                val t3 :
                  ?sep:char ->
                  'Bap.Std.Self.Config.converter ->
                  'Bap.Std.Self.Config.converter ->
                  'Bap.Std.Self.Config.converter ->
                  ('a * 'b * 'c) Bap.Std.Self.Config.converter
                val t4 :
                  ?sep:char ->
                  'Bap.Std.Self.Config.converter ->
                  'Bap.Std.Self.Config.converter ->
                  'Bap.Std.Self.Config.converter ->
                  'Bap.Std.Self.Config.converter ->
                  ('a * 'b * 'c * 'd) Bap.Std.Self.Config.converter
                val some :
                  ?none:string ->
                  'Bap.Std.Self.Config.converter ->
                  'a option Bap.Std.Self.Config.converter
              end
          end
      module Log : sig val start : ?logdir:string -> unit -> unit end
      module Monad :
        sig
          module type Basic = Core_kernel.Std.Monad.Basic
          module type Basic2 = Core_kernel.Std.Monad.Basic2
          module type Infix = Core_kernel.Std.Monad.Infix
          module type Infix2 = Core_kernel.Std.Monad.Infix2
          module type S = Core_kernel.Std.Monad.S
          module type S2 = Core_kernel.Std.Monad.S2
          module Make :
            functor (M : Basic->
              sig
                val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                module Monad_infix :
                  sig
                    val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                    val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                  end
                val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                val return : '-> 'M.t
                val map : 'M.t -> f:('-> 'b) -> 'M.t
                val join : 'M.t M.t -> 'M.t
                val ignore_m : 'M.t -> unit M.t
                val all : 'M.t list -> 'a list M.t
                val all_ignore : unit M.t list -> unit M.t
                module Let_syntax :
                  sig
                    val return : '-> 'M.t
                    val ( >>= ) : 'M.t -> ('-> 'M.t) -> 'M.t
                    val ( >>| ) : 'M.t -> ('-> 'b) -> 'M.t
                    module Let_syntax :
                      sig
                        val return : '-> 'M.t
                        val bind : 'M.t -> f:('-> 'M.t) -> 'M.t
                        val map : 'M.t -> f:('-> 'b) -> 'M.t
                        val both : 'M.t -> 'M.t -> ('a * 'b) M.t
                        module Open_on_rhs : sig  end
                      end
                  end
              end
          module Make2 :
            functor (M : Basic2->
              sig
                val ( >>= ) :
                  ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                module Let_syntax :
                  sig
                    val return : '-> ('a, 'b) M.t
                    val ( >>= ) :
                      ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                    module Let_syntax :
                      sig
                        val return : '-> ('a, 'b) M.t
                        val bind :
                          ('a, 'e) M.t ->
                          f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                        val map :
                          ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                        val both :
                          ('a, 'e) M.t -> ('b, 'e) M.t -> ('a * 'b, 'e) M.t
                        module Open_on_rhs : sig  end
                      end
                  end
                module Monad_infix :
                  sig
                    val ( >>= ) :
                      ('a, 'e) M.t -> ('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                    val ( >>| ) : ('a, 'e) M.t -> ('-> 'b) -> ('b, 'e) M.t
                  end
                val bind :
                  ('a, 'e) M.t -> f:('-> ('b, 'e) M.t) -> ('b, 'e) M.t
                val return : '-> ('a, 'b) M.t
                val map : ('a, 'e) M.t -> f:('-> 'b) -> ('b, 'e) M.t
                val join : (('a, 'e) M.t, 'e) M.t -> ('a, 'e) M.t
                val ignore_m : ('a, 'e) M.t -> (unit, 'e) M.t
                val all : ('a, 'e) M.t list -> ('a list, 'e) M.t
                val all_ignore : (unit, 'e) M.t list -> (unit, 'e) M.t
              end
          module State :
            sig
              module type S =
                sig
                  type ('a, 's) t
                  type 'a result
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                      module Let_syntax :
                        sig
                          val return : '-> ('a, 'b) t
                          val bind :
                            ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                          val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                          val both :
                            ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                          module Open_on_rhs : sig  end
                        end
                    end
                  module Monad_infix :
                    sig
                      val ( >>= ) :
                        ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                      val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                    end
                  val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                  val return : '-> ('a, 'b) t
                  val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                  val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                  val ignore_m : ('a, 'e) t -> (unit, 'e) t
                  val all : ('a, 'e) t list -> ('a list, 'e) t
                  val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                  val put : '-> (unit, 's) t
                  val get : unit -> ('s, 's) t
                  val gets : ('-> 'r) -> ('r, 's) t
                  val update : ('-> 's) -> (unit, 's) t
                  val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
                  val run : ('a, 's) t -> '-> ('a * 's) result
                  val eval : ('a, 's) t -> '-> 'a result
                  val exec : ('a, 's) t -> '-> 's result
                end
              type ('a, 'e) t = ('a, 'e) Taint.state
              type 'a result = 'a
              val ( >>= ) : ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
              val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
              module Let_syntax :
                sig
                  val return : '-> ('a, 'b) t
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                  module Let_syntax :
                    sig
                      val return : '-> ('a, 'b) t
                      val bind :
                        ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                      val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                      val both : ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                      module Open_on_rhs : sig  end
                    end
                end
              module Monad_infix :
                sig
                  val ( >>= ) :
                    ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                  val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                end
              val bind : ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
              val return : '-> ('a, 'b) t
              val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
              val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
              val ignore_m : ('a, 'e) t -> (unit, 'e) t
              val all : ('a, 'e) t list -> ('a list, 'e) t
              val all_ignore : (unit, 'e) t list -> (unit, 'e) t
              val put : '-> (unit, 's) t
              val get : unit -> ('s, 's) t
              val gets : ('-> 'r) -> ('r, 's) t
              val update : ('-> 's) -> (unit, 's) t
              val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
              val run : ('a, 's) t -> '-> 'a * 's
              val eval : ('a, 's) t -> '-> 'a
              val exec : ('a, 's) t -> '-> 's
            end
          module T :
            sig
              module Option :
                sig
                  module Make :
                    functor (M : S->
                      sig
                        type 'a t = 'a option M.t
                        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                        module Monad_infix :
                          sig
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                          end
                        val bind : 'a t -> f:('-> 'b t) -> 'b t
                        val return : '-> 'a t
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val join : 'a t t -> 'a t
                        val ignore_m : 'a t -> unit t
                        val all : 'a t list -> 'a list t
                        val all_ignore : unit t list -> unit t
                        module Let_syntax :
                          sig
                            val return : '-> 'a t
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                            module Let_syntax :
                              sig
                                val return : '-> 'a t
                                val bind : 'a t -> f:('-> 'b t) -> 'b t
                                val map : 'a t -> f:('-> 'b) -> 'b t
                                val both : 'a t -> 'b t -> ('a * 'b) t
                                module Open_on_rhs : sig  end
                              end
                          end
                      end
                  module Make2 :
                    functor (M : S2->
                      sig
                        type ('a, 'b) t = ('a option, 'b) M.t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val bind :
                                  ('a, 'e) t ->
                                  f:('-> ('b, 'e) t) -> ('b, 'e) t
                                val map :
                                  ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                                val both :
                                  ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          end
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val return : '-> ('a, 'b) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                        val ignore_m : ('a, 'e) t -> (unit, 'e) t
                        val all : ('a, 'e) t list -> ('a list, 'e) t
                        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                      end
                end
              module Or_error :
                sig
                  module Make :
                    functor (M : S->
                      sig
                        type 'a t = 'Memory.With_error.m M.t
                        val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                        val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                        module Monad_infix :
                          sig
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                          end
                        val bind : 'a t -> f:('-> 'b t) -> 'b t
                        val return : '-> 'a t
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val join : 'a t t -> 'a t
                        val ignore_m : 'a t -> unit t
                        val all : 'a t list -> 'a list t
                        val all_ignore : unit t list -> unit t
                        module Let_syntax :
                          sig
                            val return : '-> 'a t
                            val ( >>= ) : 'a t -> ('-> 'b t) -> 'b t
                            val ( >>| ) : 'a t -> ('-> 'b) -> 'b t
                            module Let_syntax :
                              sig
                                val return : '-> 'a t
                                val bind : 'a t -> f:('-> 'b t) -> 'b t
                                val map : 'a t -> f:('-> 'b) -> 'b t
                                val both : 'a t -> 'b t -> ('a * 'b) t
                                module Open_on_rhs : sig  end
                              end
                          end
                      end
                  module Make2 :
                    functor (M : S2->
                      sig
                        type ('a, 'b) t = ('Memory.With_error.m, 'b) M.t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val bind :
                                  ('a, 'e) t ->
                                  f:('-> ('b, 'e) t) -> ('b, 'e) t
                                val map :
                                  ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                                val both :
                                  ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          end
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val return : '-> ('a, 'b) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                        val ignore_m : ('a, 'e) t -> (unit, 'e) t
                        val all : ('a, 'e) t list -> ('a list, 'e) t
                        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                      end
                end
              module Result :
                sig
                  module Make :
                    functor (M : S->
                      sig
                        type ('a, 'e) t =
                            ('a, 'e) Core_kernel.Std.Result.t M.t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val bind :
                                  ('a, 'e) t ->
                                  f:('-> ('b, 'e) t) -> ('b, 'e) t
                                val map :
                                  ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                                val both :
                                  ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          end
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val return : '-> ('a, 'b) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                        val ignore_m : ('a, 'e) t -> (unit, 'e) t
                        val all : ('a, 'e) t list -> ('a list, 'e) t
                        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                      end
                end
              module State :
                sig
                  module Make :
                    functor (M : S->
                      sig
                        type ('a, 's) t
                        type 'a result = 'M.t
                        val ( >>= ) :
                          ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                        val ( >>| ) : ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                        module Let_syntax :
                          sig
                            val return : '-> ('a, 'b) t
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                            module Let_syntax :
                              sig
                                val return : '-> ('a, 'b) t
                                val bind :
                                  ('a, 'e) t ->
                                  f:('-> ('b, 'e) t) -> ('b, 'e) t
                                val map :
                                  ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                                val both :
                                  ('a, 'e) t -> ('b, 'e) t -> ('a * 'b, 'e) t
                                module Open_on_rhs : sig  end
                              end
                          end
                        module Monad_infix :
                          sig
                            val ( >>= ) :
                              ('a, 'e) t -> ('-> ('b, 'e) t) -> ('b, 'e) t
                            val ( >>| ) :
                              ('a, 'e) t -> ('-> 'b) -> ('b, 'e) t
                          end
                        val bind :
                          ('a, 'e) t -> f:('-> ('b, 'e) t) -> ('b, 'e) t
                        val return : '-> ('a, 'b) t
                        val map : ('a, 'e) t -> f:('-> 'b) -> ('b, 'e) t
                        val join : (('a, 'e) t, 'e) t -> ('a, 'e) t
                        val ignore_m : ('a, 'e) t -> (unit, 'e) t
                        val all : ('a, 'e) t list -> ('a list, 'e) t
                        val all_ignore : (unit, 'e) t list -> (unit, 'e) t
                        val put : '-> (unit, 's) t
                        val get : unit -> ('s, 's) t
                        val gets : ('-> 'r) -> ('r, 's) t
                        val update : ('-> 's) -> (unit, 's) t
                        val modify : ('a, 's) t -> ('-> 's) -> ('a, 's) t
                        val run : ('a, 's) t -> '-> ('a * 's) result
                        val eval : ('a, 's) t -> '-> 'a result
                        val exec : ('a, 's) t -> '-> 's result
                      end
                end
            end
        end
    end
end